envio 3.9.0 → 3.10.0-subgraph

package/src/Utils.res.mjs

@@ -3,6 +3,8 @@ import packageJson from '../package.json' with { type: 'json' }
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
@@ -14,6 +16,22 @@ import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
+function jitter(delay) {
+  return (delay / 2 | 0) + (Math.random() * (delay / 2 | 0) | 0) | 0;
+}
+
+function clearTimeoutRef(timeoutId) {
+  let id = timeoutId.contents;
+  if (id !== undefined) {
+    clearTimeout(Primitive_option.valFromOption(id));
+  }
+  timeoutId.contents = undefined;
+}
+
+function expBackoff(base, exp, maxMillis) {
+  return Primitive_int.min(base * (Math.pow(2.0, Primitive_int.min(exp, 20)) | 0) | 0, maxMillis);
+}
+
 function delay(milliseconds) {
   return new Promise((resolve, param) => {
     setTimeout(() => resolve(), milliseconds);
@@ -61,6 +79,11 @@ let Option = {
   getExn: getExn
 };
 
+function incrementBy(dict, key, count) {
+  let current = dict[key];
+  dict[key] = current !== undefined ? current + count | 0 : count;
+}
+
 function getOrInsertEmptyDict(dict, key) {
   let d = dict[key];
   if (d !== undefined) {
@@ -169,6 +192,7 @@ let shallowCopy = ((dict) => ({...dict}));
 
 let Dict = {
   $$delete: Stdlib_Dict.$$delete,
+  incrementBy: incrementBy,
   getOrInsertEmptyDict: getOrInsertEmptyDict,
   push: push,
   pushMany: pushMany,
@@ -211,6 +235,10 @@ let UnsafeIntOperators = {};
 
 let immutableEmpty = [];
 
+function quotedJoin(names) {
+  return names.map(name => `"` + name + `"`).join(", ");
+}
+
 function mergeSorted(f, xs, ys) {
   if (xs.length === 0) {
     return ys;
@@ -393,6 +421,7 @@ let $$Array$1 = {
   partition: Stdlib_Array.partition,
   unzip: Stdlib_Array.unzip,
   immutableEmpty: immutableEmpty,
+  quotedJoin: quotedJoin,
   mergeSorted: mergeSorted,
   clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
@@ -462,15 +491,120 @@ function unwrapResultExn(res) {
   throw res._0;
 }
 
+let asUint8Array = ((value) =>
+    value instanceof Uint8Array
+      ? value.constructor === Uint8Array
+        ? value
+        : new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+      : undefined);
+
+function toHex(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("hex");
+}
+
+function toPgArrayLiteral(values) {
+  return "{" + values.map(value => {
+    if (value == null) {
+      return "NULL";
+    }
+    let bytes = asUint8Array(value);
+    if (bytes !== undefined) {
+      return `"\\\\x` + toHex(bytes) + `"`;
+    } else if (Array.isArray(value)) {
+      return toPgArrayLiteral(value);
+    } else {
+      return Stdlib_JsError.throwWithMessage("Expected Uint8Array");
+    }
+  }).join(",") + "}";
+}
+
+function compare(a, b) {
+  let aLength = a.length;
+  let bLength = b.length;
+  let _index = 0;
+  while (true) {
+    let index = _index;
+    if (index === aLength || index === bLength) {
+      return Primitive_int.compare(aLength, bLength);
+    }
+    let order = Primitive_int.compare(a[index], b[index]);
+    if (order !== 0) {
+      return order;
+    }
+    _index = index + 1 | 0;
+    continue;
+  };
+}
+
+let Bytes = {
+  asUint8Array: asUint8Array,
+  toHex: toHex,
+  toPgArrayLiteral: toPgArrayLiteral,
+  compare: compare
+};
+
 let variantTag = S$RescriptSchema.union([
   S$RescriptSchema.string,
   S$RescriptSchema.object(s => s.f("TAG", S$RescriptSchema.string))
 ]);
 
+function nullTolerant(schema) {
+  return S$RescriptSchema.transform(S$RescriptSchema.$$null(schema), param => ({
+    p: value => value,
+    s: value => {
+      if (value == null) {
+        return;
+      } else {
+        return Primitive_option.some(value);
+      }
+    }
+  }));
+}
+
+let bytes = S$RescriptSchema.custom("Bytes", s => ({
+  p: unknown => {
+    let bytes = asUint8Array(unknown);
+    if (bytes !== undefined) {
+      return bytes;
+    } else {
+      return s.fail("Expected Uint8Array", undefined);
+    }
+  },
+  s: bytes => bytes
+}));
+
+let bytesArray = S$RescriptSchema.custom("BytesArray", s => ({
+  p: unknown => {
+    if (Array.isArray(unknown)) {
+      return unknown.map(item => {
+        let bytes = asUint8Array(item);
+        if (bytes !== undefined) {
+          return bytes;
+        } else {
+          return s.fail("Expected Uint8Array", undefined);
+        }
+      });
+    } else {
+      return s.fail("Expected array of Uint8Array", undefined);
+    }
+  },
+  s: toPgArrayLiteral
+}));
+
 let dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
   s: date => date.toISOString()
 }));
 
+let clickHouseJson = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
+  s: value => {
+    if (value == null) {
+      return "null";
+    } else {
+      return value;
+    }
+  }
+}));
+
 let clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
   s: date => date.getTime()
 }));
@@ -506,7 +640,11 @@ function coerceToJsonPgType(schema) {
 
 let Schema = {
   variantTag: variantTag,
+  nullTolerant: nullTolerant,
+  bytes: bytes,
+  bytesArray: bytesArray,
   dbDate: dbDate,
+  clickHouseJson: clickHouseJson,
   clickHouseDate: clickHouseDate,
   coerceToJsonPgType: coerceToJsonPgType
 };
@@ -640,6 +778,13 @@ function prettifyExn(exn) {
   }
 }
 
+function exnMessage(exn) {
+  let jsExn = Primitive_exceptions.internalToException(exn);
+  if (jsExn.RE_EXN_ID === "JsExn") {
+    return Stdlib_JsExn.message(jsExn._1);
+  }
+}
+
 let value;
 
 try {
@@ -695,7 +840,13 @@ let $$Promise$1 = {
   isCatchable: isCatchable
 };
 
+let maxBackoffExponent = 20;
+
 export {
+  jitter,
+  clearTimeoutRef,
+  maxBackoffExponent,
+  expBackoff,
   delay,
   $$Object,
   $$Error,
@@ -708,6 +859,7 @@ export {
   Url,
   Result,
   unwrapResultExn,
+  Bytes,
   Schema,
   getVariantsTags,
   $$Set,
@@ -717,6 +869,7 @@ export {
   $$Proxy,
   Hash,
   prettifyExn,
+  exnMessage,
   EnvioPackage,
   $$BigInt,
   $$Promise$1 as $$Promise,

package/src/Writing.res

@@ -158,8 +158,8 @@ let runOneWrite = async (state: IndexerState.t) => {
     state->IndexerState.markCommitted(~upToCheckpointId)
 
     switch rollback {
-    | Some({progressBlockNumberByChainId}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
-      await RollbackCommit.fire(~progressBlockNumberByChainId)
+    | Some({progressedChains}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
+      await RollbackCommit.fire(~progressedChains)
     | _ => ()
     }
 

package/src/Writing.res.mjs

@@ -130,7 +130,7 @@ async function runOneWrite(state) {
   ]);
   IndexerState.markCommitted(state, upToCheckpointId);
   if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
-    await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
+    await RollbackCommit.fire(rollback.progressedChains);
   }
   return await PruneStaleHistory.runForced(state, pruneTargets);
 }