envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/bindings/ClickHouse.res

@@ -46,7 +46,10 @@ let getClickHouseFieldType = (
   let baseType = switch fieldType {
   | Int32 => "Int32"
   | Uint32 => "UInt32"
+  | UInt52 => "UInt64"
+  | UInt64 => "UInt64"
   | Serial => "Int32"
+  | BigSerial => "Int64"
   | BigInt({?precision}) =>
     switch precision {
     | None => "String" // Fallback for unbounded BigInt
@@ -98,6 +101,97 @@ let getClickHouseFieldType = (
   isNullable ? `Nullable(${baseType})` : baseType
 }
 
+// Creates an entity schema from table definition, using clickHouseDate for Date fields
+let makeClickHouseEntitySchema = (table: Table.table): S.t<Internal.entity> => {
+  S.schema(s => {
+    let dict = Js.Dict.empty()
+    table.fields->Belt.Array.forEach(field => {
+      switch field {
+      | Field(f) => {
+          let fieldName = f->Table.getDbFieldName
+          let fieldSchema = switch f.fieldType {
+          | Date => {
+              let dateSchema = Utils.Schema.clickHouseDate->S.toUnknown
+              if f.isNullable {
+                S.null(dateSchema)->S.toUnknown
+              } else if f.isArray {
+                S.array(dateSchema)->S.toUnknown
+              } else {
+                dateSchema
+              }
+            }
+          // ClickHouse returns UInt64 values as strings, need to parse to float
+          | UInt52 => {
+              let uint52Schema =
+                S.float
+                ->S.preprocess(_ => {
+                  parser: unknown =>
+                    unknown->(Utils.magic: unknown => string)->Js.Float.fromString,
+                })
+                ->S.toUnknown
+              if f.isNullable {
+                S.null(uint52Schema)->S.toUnknown
+              } else if f.isArray {
+                S.array(uint52Schema)->S.toUnknown
+              } else {
+                uint52Schema
+              }
+            }
+          | _ => f.fieldSchema
+          }
+          dict->Js.Dict.set(fieldName, s.matches(fieldSchema))
+        }
+      | DerivedFrom(_) => () // Skip derived fields
+      }
+    })
+    dict->(Utils.magic: Js.Dict.t<unknown> => Internal.entity)
+  })
+}
+
+let logger = Logging.createChild(~params={"context": "ClickHouse"})
+
+// On transient failure, split values in half and retry each half.
+// If only 1 row remains, retry with delay.
+// Delay scales from 100ms to 1000ms as retries decrease.
+let rec insertWithRetry = async (
+  client,
+  ~table: string,
+  ~values: array<'a>,
+  ~format: string,
+  ~retries=8,
+) => {
+  try {
+    await client->insert({table, values, format})
+  } catch {
+  | exn if retries > 0 =>
+    let delayMs = Js.Math.min_int(1000, 100 + 900 * (8 - retries) / 7)
+    if Array.length(values) > 1 {
+      logger->Logging.childWarn({
+        "msg": "ClickHouse insert failed, splitting batch in half and retrying",
+        "table": table,
+        "batchSize": Array.length(values),
+        "retriesLeft": retries,
+        "err": exn->Utils.prettifyExn,
+      })
+      await Utils.delay(delayMs)
+      let mid = Array.length(values) / 2
+      let first = values->Js.Array2.slice(~start=0, ~end_=mid)
+      let second = values->Js.Array2.sliceFrom(mid)
+      await insertWithRetry(client, ~table, ~values=first, ~format, ~retries=retries - 1)
+      await insertWithRetry(client, ~table, ~values=second, ~format, ~retries=retries - 1)
+    } else {
+      logger->Logging.childWarn({
+        "msg": "ClickHouse insert failed, retrying after delay",
+        "table": table,
+        "retriesLeft": retries,
+        "err": exn->Utils.prettifyExn,
+      })
+      await Utils.delay(delayMs)
+      await insertWithRetry(client, ~table, ~values, ~format, ~retries=retries - 1)
+    }
+  }
+}
+
 let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) => {
   let checkpointsCount = batch.checkpointIds->Array.length
   if checkpointsCount === 0 {
@@ -108,7 +202,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),
@@ -118,11 +212,12 @@ let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) =
     }
 
     try {
-      await client->insert({
-        table: `${database}.\`${InternalTable.Checkpoints.table.tableName}\``,
-        values: checkpointRows,
-        format: "JSONCompactEachRow",
-      })
+      await insertWithRetry(
+        client,
+        ~table=`${database}.\`${InternalTable.Checkpoints.table.tableName}\``,
+        ~values=checkpointRows,
+        ~format="JSONCompactEachRow",
+      )
     } catch {
     | exn =>
       raise(
@@ -135,8 +230,14 @@ let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) =
   }
 }
 
+type setUpdatesCache = {
+  tableName: string,
+  convertOrThrow: Change.t<Internal.entity> => Js.Json.t,
+}
+
 let setUpdatesOrThrow = async (
   client,
+  ~cache: Utils.WeakMap.t<Internal.entityConfig, setUpdatesCache>,
   ~updates: array<Internal.inMemoryStoreEntityUpdate<Internal.entity>>,
   ~entityConfig: Internal.entityConfig,
   ~database: string,
@@ -144,17 +245,17 @@ let setUpdatesOrThrow = async (
   if updates->Array.length === 0 {
     ()
   } else {
-    let {convertOrThrow, tableName} = switch entityConfig.clickHouseSetUpdatesCache {
-    | Some(cache) => cache
+    let {convertOrThrow, tableName} = switch cache->Utils.WeakMap.get(entityConfig) {
+    | Some(cached) => cached
     | None =>
-      let cache: Internal.clickHouseSetUpdatesCache = {
+      let cached: setUpdatesCache = {
         tableName: `${database}.\`${EntityHistory.historyTableName(
             ~entityName=entityConfig.name,
             ~entityIndex=entityConfig.index,
           )}\``,
         convertOrThrow: S.compile(
           S.union([
-            EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+            EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
             S.object(s => {
               s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
               Change.Delete({
@@ -173,8 +274,8 @@ let setUpdatesOrThrow = async (
         ),
       }
 
-      entityConfig.clickHouseSetUpdatesCache = Some(cache)
-      cache
+      cache->Utils.WeakMap.set(entityConfig, cached)->ignore
+      cached
     }
 
     try {
@@ -183,11 +284,7 @@ let setUpdatesOrThrow = async (
         update.latestChange->convertOrThrow
       })
 
-      await client->insert({
-        table: tableName,
-        values,
-        format: "JSONEachRow",
-      })
+      await insertWithRetry(client, ~table=tableName, ~values, ~format="JSONEachRow")
     } catch {
     | exn =>
       raise(
@@ -224,7 +321,7 @@ let makeCreateHistoryTableQuery = (~entityConfig: Internal.entityConfig, ~databa
     )}\` (
   ${fieldDefinitions->Js.Array2.joinWith(",\n  ")},
   \`${EntityHistory.checkpointIdFieldName}\` ${getClickHouseFieldType(
-      ~fieldType=Uint32,
+      ~fieldType=UInt64,
       ~isNullable=false,
       ~isArray=false,
     )},
@@ -247,7 +344,7 @@ let makeCreateCheckpointsTableQuery = (~database: string) => {
   let eventsProcessedField = (#events_processed: InternalTable.Checkpoints.field :> string)
 
   `CREATE TABLE IF NOT EXISTS ${database}.\`${InternalTable.Checkpoints.table.tableName}\` (
-  \`${idField}\` ${getClickHouseFieldType(~fieldType=Int32, ~isNullable=false, ~isArray=false)},
+  \`${idField}\` ${getClickHouseFieldType(~fieldType=UInt64, ~isNullable=false, ~isArray=false)},
   \`${chainIdField}\` ${getClickHouseFieldType(
       ~fieldType=Int32,
       ~isNullable=false,
@@ -264,7 +361,7 @@ let makeCreateCheckpointsTableQuery = (~database: string) => {
       ~isArray=false,
     )},
   \`${eventsProcessedField}\` ${getClickHouseFieldType(
-      ~fieldType=Int32,
+      ~fieldType=UInt64,
       ~isNullable=false,
       ~isArray=false,
     )}
@@ -343,7 +440,7 @@ let initialize = async (
 }
 
 // Resume ClickHouse sink after reorg by deleting rows with checkpoint IDs higher than target
-let resume = async (client, ~database: string, ~checkpointId: float) => {
+let resume = async (client, ~database: string, ~checkpointId: Internal.checkpointId) => {
   try {
     // Try to use the database - will throw if it doesn't exist
     try {
@@ -368,14 +465,14 @@ let resume = async (client, ~database: string, ~checkpointId: float) => {
       tables->Belt.Array.map(table => {
         let tableName = table["name"]
         client->exec({
-          query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->Belt.Float.toString}`,
+          query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->BigInt.toString}`,
         })
       }),
     )->Promise.ignoreValue
 
     // Delete stale checkpoints
     await client->exec({
-      query: `DELETE FROM ${database}.\`${InternalTable.Checkpoints.table.tableName}\` WHERE \`${Table.idFieldName}\` > ${checkpointId->Belt.Float.toString}`,
+      query: `DELETE FROM ${database}.\`${InternalTable.Checkpoints.table.tableName}\` WHERE \`${Table.idFieldName}\` > ${checkpointId->BigInt.toString}`,
     })
   } catch {
   | Persistence.StorageError(_) as exn => raise(exn)

package/src/bindings/ClickHouse.res.mjs

@@ -21,6 +21,10 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
       case "Uint32" :
           baseType = "UInt32";
           break;
+      case "UInt52" :
+      case "UInt64" :
+          baseType = "UInt64";
+          break;
       case "Number" :
           baseType = "Float64";
           break;
@@ -28,6 +32,9 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
       case "Serial" :
           baseType = "Int32";
           break;
+      case "BigSerial" :
+          baseType = "Int64";
+          break;
       case "String" :
       case "Json" :
           baseType = "String";
@@ -76,6 +83,94 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
   }
 }
 
+function makeClickHouseEntitySchema(table) {
+  return S$RescriptSchema.schema(function (s) {
+              var dict = {};
+              Belt_Array.forEach(table.fields, (function (field) {
+                      if (field.TAG !== "Field") {
+                        return ;
+                      }
+                      var f = field._0;
+                      var fieldName = Table.getDbFieldName(f);
+                      var match = f.fieldType;
+                      var fieldSchema;
+                      if (typeof match !== "object") {
+                        switch (match) {
+                          case "UInt52" :
+                              var uint52Schema = S$RescriptSchema.preprocess(S$RescriptSchema.$$float, (function (param) {
+                                      return {
+                                              p: (function (unknown) {
+                                                  return Number(unknown);
+                                                })
+                                            };
+                                    }));
+                              fieldSchema = f.isNullable ? S$RescriptSchema.$$null(uint52Schema) : (
+                                  f.isArray ? S$RescriptSchema.array(uint52Schema) : uint52Schema
+                                );
+                              break;
+                          case "Date" :
+                              var dateSchema = Utils.Schema.clickHouseDate;
+                              fieldSchema = f.isNullable ? S$RescriptSchema.$$null(dateSchema) : (
+                                  f.isArray ? S$RescriptSchema.array(dateSchema) : dateSchema
+                                );
+                              break;
+                          default:
+                            fieldSchema = f.fieldSchema;
+                        }
+                      } else {
+                        fieldSchema = f.fieldSchema;
+                      }
+                      dict[fieldName] = s.m(fieldSchema);
+                    }));
+              return dict;
+            });
+}
+
+var logger = Logging.createChild({
+      context: "ClickHouse"
+    });
+
+async function insertWithRetry(client, table, values, format, retriesOpt) {
+  var retries = retriesOpt !== undefined ? retriesOpt : 8;
+  try {
+    return await client.insert({
+                table: table,
+                values: values,
+                format: format
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (retries > 0) {
+      var delayMs = Math.min(1000, 100 + (Math.imul(900, 8 - retries | 0) / 7 | 0) | 0);
+      if (values.length > 1) {
+        Logging.childWarn(logger, {
+              msg: "ClickHouse insert failed, splitting batch in half and retrying",
+              table: table,
+              batchSize: values.length,
+              retriesLeft: retries,
+              err: Utils.prettifyExn(exn)
+            });
+        await Utils.delay(delayMs);
+        var mid = (values.length >> 1);
+        var first = values.slice(0, mid);
+        var second = values.slice(mid);
+        await insertWithRetry(client, table, first, format, retries - 1 | 0);
+        return await insertWithRetry(client, table, second, format, retries - 1 | 0);
+      }
+      Logging.childWarn(logger, {
+            msg: "ClickHouse insert failed, retrying after delay",
+            table: table,
+            retriesLeft: retries,
+            err: Utils.prettifyExn(exn)
+          });
+      await Utils.delay(delayMs);
+      return await insertWithRetry(client, table, values, format, retries - 1 | 0);
+    }
+    throw exn;
+  }
+}
+
 async function setCheckpointsOrThrow(client, batch, database) {
   var checkpointsCount = batch.checkpointIds.length;
   if (checkpointsCount === 0) {
@@ -84,7 +179,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],
@@ -92,11 +187,7 @@ async function setCheckpointsOrThrow(client, batch, database) {
         ]);
   }
   try {
-    return await client.insert({
-                table: database + ".\`" + InternalTable.Checkpoints.table.tableName + "\`",
-                values: checkpointRows,
-                format: "JSONCompactEachRow"
-              });
+    return await insertWithRetry(client, database + ".\`" + InternalTable.Checkpoints.table.tableName + "\`", checkpointRows, "JSONCompactEachRow", undefined);
   }
   catch (raw_exn){
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -109,18 +200,18 @@ async function setCheckpointsOrThrow(client, batch, database) {
   }
 }
 
-async function setUpdatesOrThrow(client, updates, entityConfig, database) {
+async function setUpdatesOrThrow(client, cache, updates, entityConfig, database) {
   if (updates.length === 0) {
     return ;
   }
-  var cache = entityConfig.clickHouseSetUpdatesCache;
+  var cached = cache.get(entityConfig);
   var match;
-  if (cache !== undefined) {
-    match = cache;
+  if (cached !== undefined) {
+    match = cached;
   } else {
-    var cache_tableName = database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\`";
-    var cache_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
-              EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+    var cached_tableName = database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\`";
+    var cached_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
+              EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
               S$RescriptSchema.object(function (s) {
                     s.tag(EntityHistory.changeFieldName, "DELETE");
                     return {
@@ -130,12 +221,12 @@ async function setUpdatesOrThrow(client, updates, entityConfig, database) {
                           };
                   })
             ]), "Output", "Json", "Sync", false);
-    var cache$1 = {
-      tableName: cache_tableName,
-      convertOrThrow: cache_convertOrThrow
+    var cached$1 = {
+      tableName: cached_tableName,
+      convertOrThrow: cached_convertOrThrow
     };
-    entityConfig.clickHouseSetUpdatesCache = cache$1;
-    match = cache$1;
+    cache.set(entityConfig, cached$1);
+    match = cached$1;
   }
   var convertOrThrow = match.convertOrThrow;
   var tableName = match.tableName;
@@ -143,11 +234,7 @@ async function setUpdatesOrThrow(client, updates, entityConfig, database) {
     var values = updates.map(function (update) {
           return convertOrThrow(update.latestChange);
         });
-    return await client.insert({
-                table: tableName,
-                values: values,
-                format: "JSONEachRow"
-              });
+    return await insertWithRetry(client, tableName, values, "JSONEachRow", undefined);
   }
   catch (raw_exn){
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -170,14 +257,14 @@ function makeCreateHistoryTableQuery(entityConfig, database) {
           var clickHouseType = getClickHouseFieldType(field$1.fieldType, field$1.isNullable, field$1.isArray);
           return "\`" + fieldName + "\` " + clickHouseType;
         }));
-  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\` (\n  " + fieldDefinitions.join(",\n  ") + ",\n  \`" + EntityHistory.checkpointIdFieldName + "\` " + getClickHouseFieldType("Uint32", false, false) + ",\n  \`" + EntityHistory.changeFieldName + "\` " + getClickHouseFieldType({
+  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\` (\n  " + fieldDefinitions.join(",\n  ") + ",\n  \`" + EntityHistory.checkpointIdFieldName + "\` " + getClickHouseFieldType("UInt64", false, false) + ",\n  \`" + EntityHistory.changeFieldName + "\` " + getClickHouseFieldType({
               type: "Enum",
               config: EntityHistory.RowAction.config
             }, false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + Table.idFieldName + ", " + EntityHistory.checkpointIdFieldName + ")";
 }
 
 function makeCreateCheckpointsTableQuery(database) {
-  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` (\n  \`" + "id" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "chain_id" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_number" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_hash" + "\` " + getClickHouseFieldType("String", true, false) + ",\n  \`" + "events_processed" + "\` " + getClickHouseFieldType("Int32", false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + "id" + ")";
+  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` (\n  \`" + "id" + "\` " + getClickHouseFieldType("UInt64", false, false) + ",\n  \`" + "chain_id" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_number" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_hash" + "\` " + getClickHouseFieldType("String", true, false) + ",\n  \`" + "events_processed" + "\` " + getClickHouseFieldType("UInt64", false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + "id" + ")";
 }
 
 function makeCreateViewQuery(entityConfig, database) {
@@ -245,11 +332,11 @@ async function resume(client, database, checkpointId) {
     await Promise.all(Belt_Array.map(tables, (function (table) {
                 var tableName = table.name;
                 return client.exec({
-                            query: "ALTER TABLE " + database + ".\`" + tableName + "\` DELETE WHERE \`" + EntityHistory.checkpointIdFieldName + "\` > " + String(checkpointId)
+                            query: "ALTER TABLE " + database + ".\`" + tableName + "\` DELETE WHERE \`" + EntityHistory.checkpointIdFieldName + "\` > " + checkpointId.toString()
                           });
               })));
     return await client.exec({
-                query: "DELETE FROM " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` WHERE \`" + Table.idFieldName + "\` > " + String(checkpointId)
+                query: "DELETE FROM " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` WHERE \`" + Table.idFieldName + "\` > " + checkpointId.toString()
               });
   }
   catch (raw_exn$1){
@@ -264,6 +351,9 @@ async function resume(client, database, checkpointId) {
 
 export {
   getClickHouseFieldType ,
+  makeClickHouseEntitySchema ,
+  logger ,
+  insertWithRetry ,
   setCheckpointsOrThrow ,
   setUpdatesOrThrow ,
   makeCreateHistoryTableQuery ,
@@ -272,4 +362,4 @@ export {
   initialize ,
   resume ,
 }
-/* Table Not a pure module */
+/* logger Not a pure module */

package/src/bindings/DateFns.res

@@ -0,0 +1,74 @@
+/**
+Formats: 
+hh:mm:ss         | 00:00:00
+do MMM ''yy      | 1st Jan '21
+ha do MMM ''yy   | 8PM 1st Jan '21
+ha               | 8PM
+iii              | Tues
+iii MMM          | Tues Jan
+MMM              | Jan
+`)
+*/
+type dateFormats =
+  | @as("HH:mm:ss") HoursMinSec
+  | @as("ha") Hour
+  | @as("do MMM ''yy") DayMonthYear
+  | @as("ha do MMM ''yy") HourDayMonthYear
+  | @as("h:mma do MMM ''yy") HourMinDayMonthYear
+  | @as("iii") DayName
+  | @as("iii MMM") DayNameMonth
+  | @as("do MMM") DayMonth
+  | @as("MMM") Month
+  | @as("h:mma") HourMin
+
+@module("date-fns") external format: (Js.Date.t, dateFormats) => string = "format"
+
+type formatDistanceToNowOptions = {includeSeconds: bool}
+@module("date-fns")
+external formatDistanceToNow: Js.Date.t => string = "formatDistanceToNow"
+
+@module("date-fns")
+external formatDistance: (Js.Date.t, Js.Date.t) => string = "formatDistance"
+
+@module("date-fns")
+external formatDistanceWithOptions: (Js.Date.t, Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistance"
+
+@module("date-fns")
+external formatDistanceToNowWithOptions: (Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistanceToNow"
+
+let formatDistanceToNowWithSeconds = (date: Js.Date.t) =>
+  date->formatDistanceToNowWithOptions({includeSeconds: true})
+
+type durationTimeFormat = {
+  years: int,
+  months: int,
+  weeks: int,
+  days: int,
+  hours: int,
+  minutes: int,
+  seconds: int,
+}
+
+@module("date-fns")
+external formatRelative: (Js.Date.t, Js.Date.t) => string = "formatRelative"
+
+type durationFormatOutput = {format: array<string>}
+
+@module("date-fns")
+external formatDuration: (durationTimeFormat, durationFormatOutput) => string = "formatDuration"
+
+type interval = {start: Js_date.t, end: Js_date.t}
+
+@module("date-fns")
+external intervalToDuration: interval => durationTimeFormat = "intervalToDuration"
+
+//helper to convert millis elapsed to duration object
+let durationFromMillis = (millis: int) =>
+  intervalToDuration({
+    start: 0->(Utils.magic: int => Js_date.t),
+    end: millis->(Utils.magic: int => Js_date.t),
+  })
+
+@module("date-fns") external fromUnixTime: float => Js.Date.t = "fromUnixTime"

package/src/bindings/DateFns.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DateFns from "date-fns";
+
+function formatDistanceToNowWithSeconds(date) {
+  return DateFns.formatDistanceToNow(date, {
+              includeSeconds: true
+            });
+}
+
+function durationFromMillis(millis) {
+  return DateFns.intervalToDuration({
+              start: 0,
+              end: millis
+            });
+}
+
+export {
+  formatDistanceToNowWithSeconds ,
+  durationFromMillis ,
+}
+/* date-fns Not a pure module */

package/src/bindings/EventSource.res

@@ -1,6 +1,13 @@
 type t
 
-type options = {headers?: Js.Dict.t<string>}
+module Fetch = {
+  type args = {body?: unknown, headers?: dict<string>, method?: string, path?: string}
+  type t = (string, ~args: args) => promise<unknown>
+  // NOTE: don't try make the type t. Rescript 11 will curry the args which breaks
+  // keet the type inline. This is a workaround for now.
+  external fetch: (string, ~args: args) => promise<unknown> = "fetch"
+}
+type options = {fetch?: Fetch.t}
 
 @module("eventsource") @new
 external create: (~url: string, ~options: options=?) => t = "EventSource"

package/src/bindings/EventSource.res.mjs

@@ -1,2 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+
+var Fetch = {};
+
+export {
+  Fetch ,
+}
+/* No side effect */

package/src/bindings/Express.res

@@ -28,6 +28,7 @@ type middleware = (req, res, unit => unit) => unit
 type server
 
 @send external listen: (app, int) => server = "listen"
+@send external onError: (server, @as("error") _, Js.Exn.t => unit) => unit = "on"
 
 // res methods
 @send external sendStatus: (res, int) => unit = "sendStatus"

package/src/bindings/Hrtime.res

@@ -34,12 +34,25 @@ let toMillis = ((sec, nano): timeElapsed): milliseconds => {
   sec->secToMilli +. nano->nanoToMilli
 }
 
+let toSeconds = ((sec, nano): timeElapsed): seconds => {
+  sec +. nano /. 1_000_000_000.
+}
+
+let toSecondsFloat = (elapsed: timeElapsed): float => {
+  elapsed->toSeconds->(Utils.magic: seconds => float)
+}
+
 let toInt = float => float->Belt.Int.fromFloat
 let intFromMillis = toInt
 let intFromNanos = toInt
 let intFromSeconds = toInt
-let floatFromMillis = Utils.magic
+let floatFromMillis: milliseconds => float = v => v->(Utils.magic: milliseconds => float)
+let floatFromSeconds: seconds => float = v => v->(Utils.magic: seconds => float)
 
 let millisBetween = (~from: timeRef, ~to: timeRef): int => {
   to->toMillis->intFromMillis - from->toMillis->intFromMillis
 }
+
+let secondsBetween = (~from: timeRef, ~to: timeRef): float => {
+  to->toSecondsFloat -. from->toSecondsFloat
+}