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

package/src/TestIndexerProxyStorage.res

@@ -0,0 +1,205 @@
+open Belt
+
+// Message types for communication between worker and main thread
+type requestId = int
+
+// Serializable change with entity as JSON (for worker thread messaging)
+@tag("type")
+type serializableChange =
+  | @as("SET") Set({entityId: string, entity: Js.Json.t, checkpointId: bigint})
+  | @as("DELETE") Delete({entityId: string, checkpointId: bigint})
+
+type serializableEntityUpdate = {
+  latestChange: serializableChange,
+  history: array<serializableChange>,
+  containsRollbackDiffChange: bool,
+}
+
+type serializableUpdatedEntity = {
+  entityName: string,
+  updates: array<serializableEntityUpdate>,
+}
+
+// Worker -> Main thread payloads
+@tag("type")
+type workerPayload =
+  | @as("loadByIds") LoadByIds({tableName: string, ids: array<string>})
+  | @as("loadByField")
+  LoadByField({
+      tableName: string,
+      fieldName: string,
+      fieldValue: Js.Json.t,
+      operator: Persistence.operator,
+    })
+  | @as("writeBatch")
+  WriteBatch({
+      updatedEntities: array<serializableUpdatedEntity>,
+      checkpointIds: array<bigint>,
+      checkpointChainIds: array<int>,
+      checkpointBlockNumbers: array<int>,
+      checkpointBlockHashes: array<Js.Null.t<string>>,
+      checkpointEventsProcessed: array<int>,
+    })
+
+// Main thread -> Worker payloads
+@tag("type")
+type mainPayload =
+  | @as("response") Response({data: Js.Json.t})
+  | @as("error") Error({message: string})
+
+// Message wrapper with id
+type message<'payload> = {id: requestId, payload: 'payload}
+type workerMessage = message<workerPayload>
+type mainMessage = message<mainPayload>
+
+// Pending request tracker
+type pendingRequest = {
+  resolve: Js.Json.t => unit,
+  reject: exn => unit,
+}
+
+type t = {
+  parentPort: NodeJs.WorkerThreads.messagePort,
+  initialState: Persistence.initialState,
+  pendingRequests: dict<pendingRequest>,
+  mutable requestCounter: int,
+}
+
+let make = (~parentPort, ~initialState): t => {
+  let proxy = {
+    parentPort,
+    initialState,
+    pendingRequests: Js.Dict.empty(),
+    requestCounter: 0,
+  }
+
+  // Set up message listener for responses from main thread
+  parentPort->NodeJs.WorkerThreads.onPortMessage((msg: mainMessage) => {
+    let idStr = msg.id->Int.toString
+    let {resolve, reject} = switch proxy.pendingRequests->Utils.Dict.dangerouslyGetNonOption(
+      idStr,
+    ) {
+    | Some(pending) => pending
+    | None => Js.Exn.raiseError(`TestIndexer: No pending request found for id ${idStr}`)
+    }
+    Js.Dict.unsafeDeleteKey(proxy.pendingRequests->Obj.magic, idStr)
+
+    switch msg.payload {
+    | Response({data}) => resolve(data)
+    | Error({message}) => reject(Utils.Error.make(message))
+    }
+  })
+
+  proxy
+}
+
+let nextRequestId = (proxy: t): requestId => {
+  proxy.requestCounter = proxy.requestCounter + 1
+  proxy.requestCounter
+}
+
+let sendRequest = (proxy: t, ~payload: workerPayload): promise<Js.Json.t> => {
+  Promise.make((resolve, reject) => {
+    let id = proxy->nextRequestId
+    proxy.pendingRequests->Js.Dict.set(id->Int.toString, {resolve, reject})
+    proxy.parentPort->NodeJs.WorkerThreads.postMessage({id, payload})
+  })
+}
+
+let makeStorage = (proxy: t): Persistence.storage => {
+  isInitialized: async () => true,
+  initialize: async (~chainConfigs as _=?, ~entities as _=?, ~enums as _=?) => {
+    Js.Exn.raiseError(
+      "TestIndexer: initialize should not be called. Use resumeInitialState instead.",
+    )
+  },
+  resumeInitialState: async () => proxy.initialState,
+  loadByIdsOrThrow: async (~ids, ~table: Table.table, ~rowsSchema) => {
+    let response = await proxy->sendRequest(~payload=LoadByIds({tableName: table.tableName, ids}))
+    response->S.parseOrThrow(rowsSchema)
+  },
+  loadByFieldOrThrow: async (
+    ~fieldName,
+    ~fieldSchema,
+    ~fieldValue,
+    ~operator,
+    ~table: Table.table,
+    ~rowsSchema,
+  ) => {
+    let response = await proxy->sendRequest(
+      ~payload=LoadByField({
+        tableName: table.tableName,
+        fieldName,
+        fieldValue: fieldValue->S.reverseConvertToJsonOrThrow(fieldSchema),
+        operator,
+      }),
+    )
+    response->S.parseOrThrow(rowsSchema)
+  },
+  writeBatch: async (
+    ~batch,
+    ~rawEvents as _,
+    ~rollbackTargetCheckpointId as _,
+    ~isInReorgThreshold as _,
+    ~config as _,
+    ~allEntities as _,
+    ~updatedEffectsCache as _,
+    ~updatedEntities,
+  ) => {
+    // Encode entities to JSON for serialization across worker boundary
+    let serializableEntities = updatedEntities->Array.map((
+      {entityConfig, updates}: Persistence.updatedEntity,
+    ) => {
+      let encodeChange = (change: Change.t<Internal.entity>): serializableChange => {
+        switch change {
+        | Set({entityId, entity, checkpointId}) =>
+          Set({
+            entityId,
+            entity: entity->S.reverseConvertToJsonOrThrow(entityConfig.schema),
+            checkpointId,
+          })
+        | Delete({entityId, checkpointId}) => Delete({entityId, checkpointId})
+        }
+      }
+      {
+        entityName: entityConfig.name,
+        updates: updates->Array.map(update => {
+          latestChange: encodeChange(update.latestChange),
+          history: update.history->Array.map(encodeChange),
+          containsRollbackDiffChange: update.containsRollbackDiffChange,
+        }),
+      }
+    })
+    let _ = await proxy->sendRequest(
+      ~payload=WriteBatch({
+        updatedEntities: serializableEntities,
+        checkpointIds: batch.checkpointIds,
+        checkpointChainIds: batch.checkpointChainIds,
+        checkpointBlockNumbers: batch.checkpointBlockNumbers,
+        checkpointBlockHashes: batch.checkpointBlockHashes,
+        checkpointEventsProcessed: batch.checkpointEventsProcessed,
+      }),
+    )
+  },
+  dumpEffectCache: async () => (),
+  reset: async () => (),
+  setChainMeta: async _ => Obj.magic(),
+  pruneStaleCheckpoints: async (~safeCheckpointId as _) => (),
+  pruneStaleEntityHistory: async (~entityName as _, ~entityIndex as _, ~safeCheckpointId as _) =>
+    (),
+  getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+  getRollbackProgressDiff: async (~rollbackTargetCheckpointId as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+  getRollbackData: async (~entityConfig as _, ~rollbackTargetCheckpointId as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+}

package/src/TestIndexerProxyStorage.res.mjs

@@ -0,0 +1,151 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function make(parentPort, initialState) {
+  var proxy = {
+    parentPort: parentPort,
+    initialState: initialState,
+    pendingRequests: {},
+    requestCounter: 0
+  };
+  parentPort.on("message", (function (msg) {
+          var idStr = String(msg.id);
+          var pending = proxy.pendingRequests[idStr];
+          var match = pending !== undefined ? pending : Js_exn.raiseError("TestIndexer: No pending request found for id " + idStr);
+          Js_dict.unsafeDeleteKey(proxy.pendingRequests, idStr);
+          var match$1 = msg.payload;
+          if (match$1.type === "response") {
+            return match.resolve(match$1.data);
+          } else {
+            return match.reject(new Error(match$1.message));
+          }
+        }));
+  return proxy;
+}
+
+function nextRequestId(proxy) {
+  proxy.requestCounter = proxy.requestCounter + 1 | 0;
+  return proxy.requestCounter;
+}
+
+function sendRequest(proxy, payload) {
+  return new Promise((function (resolve, reject) {
+                var id = nextRequestId(proxy);
+                proxy.pendingRequests[String(id)] = {
+                  resolve: resolve,
+                  reject: reject
+                };
+                proxy.parentPort.postMessage({
+                      id: id,
+                      payload: payload
+                    });
+              }));
+}
+
+function makeStorage(proxy) {
+  return {
+          isInitialized: (async function () {
+              return true;
+            }),
+          initialize: (async function (param, param$1, param$2) {
+              return Js_exn.raiseError("TestIndexer: initialize should not be called. Use resumeInitialState instead.");
+            }),
+          resumeInitialState: (async function () {
+              return proxy.initialState;
+            }),
+          loadByIdsOrThrow: (async function (ids, table, rowsSchema) {
+              var response = await sendRequest(proxy, {
+                    type: "loadByIds",
+                    tableName: table.tableName,
+                    ids: ids
+                  });
+              return S$RescriptSchema.parseOrThrow(response, rowsSchema);
+            }),
+          loadByFieldOrThrow: (async function (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) {
+              var response = await sendRequest(proxy, {
+                    type: "loadByField",
+                    tableName: table.tableName,
+                    fieldName: fieldName,
+                    fieldValue: S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema),
+                    operator: operator
+                  });
+              return S$RescriptSchema.parseOrThrow(response, rowsSchema);
+            }),
+          dumpEffectCache: (async function () {
+              
+            }),
+          reset: (async function () {
+              
+            }),
+          setChainMeta: (async function (param) {
+              
+            }),
+          pruneStaleCheckpoints: (async function (param) {
+              
+            }),
+          pruneStaleEntityHistory: (async function (param, param$1, param$2) {
+              
+            }),
+          getRollbackTargetCheckpoint: (async function (param, param$1) {
+              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
+            }),
+          getRollbackProgressDiff: (async function (param) {
+              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
+            }),
+          getRollbackData: (async function (param, param$1) {
+              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
+            }),
+          writeBatch: (async function (batch, param, param$1, param$2, param$3, param$4, param$5, updatedEntities) {
+              var serializableEntities = Belt_Array.map(updatedEntities, (function (param) {
+                      var entityConfig = param.entityConfig;
+                      var encodeChange = function (change) {
+                        if (change.type === "SET") {
+                          return {
+                                  type: "SET",
+                                  entityId: change.entityId,
+                                  entity: S$RescriptSchema.reverseConvertToJsonOrThrow(change.entity, entityConfig.schema),
+                                  checkpointId: change.checkpointId
+                                };
+                        } else {
+                          return {
+                                  type: "DELETE",
+                                  entityId: change.entityId,
+                                  checkpointId: change.checkpointId
+                                };
+                        }
+                      };
+                      return {
+                              entityName: entityConfig.name,
+                              updates: Belt_Array.map(param.updates, (function (update) {
+                                      return {
+                                              latestChange: encodeChange(update.latestChange),
+                                              history: Belt_Array.map(update.history, encodeChange),
+                                              containsRollbackDiffChange: update.containsRollbackDiffChange
+                                            };
+                                    }))
+                            };
+                    }));
+              await sendRequest(proxy, {
+                    type: "writeBatch",
+                    updatedEntities: serializableEntities,
+                    checkpointIds: batch.checkpointIds,
+                    checkpointChainIds: batch.checkpointChainIds,
+                    checkpointBlockNumbers: batch.checkpointBlockNumbers,
+                    checkpointBlockHashes: batch.checkpointBlockHashes,
+                    checkpointEventsProcessed: batch.checkpointEventsProcessed
+                  });
+            })
+        };
+}
+
+export {
+  make ,
+  nextRequestId ,
+  sendRequest ,
+  makeStorage ,
+}
+/* S-RescriptSchema Not a pure module */

package/src/TopicFilter.res

@@ -16,7 +16,7 @@ type bytesHex = string
 let keccak256 = Viem.keccak256
 let bytesToHex = Viem.bytesToHex
 let concat = Viem.concat
-let castToHexUnsafe: 'a => hex = val => val->Utils.magic
+let castToHexUnsafe: 'a => hex = val => val->(Utils.magic: 'a => hex)
 let fromBigInt: bigint => hex = val => val->Viem.bigintToHex(~options={size: 32})
 let fromDynamicString: string => hex = val => val->(Utils.magic: string => hex)->keccak256
 let fromString: string => hex = val => val->Viem.stringToHex(~options={size: 32})

package/src/Types.ts

@@ -1,6 +1,6 @@
 export type Invalid = never;
 
-export type Address = string;
+export type Address = `0x${string}`;
 
 export type Logger = {
   readonly debug: (