envio 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/TestIndexerProxyStorage.res.mjs

@@ -0,0 +1,157 @@
+// 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);
+            }),
+          setOrThrow: (async function (param, param$1, param$2) {
+              
+            }),
+          setEffectCacheOrThrow: (async function (param, param$1, param$2) {
+              
+            }),
+          dumpEffectCache: (async function () {
+              
+            }),
+          executeUnsafe: (async function (param) {
+              
+            }),
+          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/Types.ts

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

package/src/UserContext.res

@@ -0,0 +1,355 @@
+let codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`
+
+type contextParams = {
+  item: Internal.item,
+  checkpointId: float,
+  inMemoryStore: InMemoryStore.t,
+  loadManager: LoadManager.t,
+  persistence: Persistence.t,
+  isPreload: bool,
+  shouldSaveHistory: bool,
+  chains: Internal.chains,
+  config: Config.t,
+  mutable isResolved: bool,
+}
+
+// We don't want to expose the params to the user
+// so instead of storing _params on the context object,
+// we use an external WeakMap
+let paramsByThis: Utils.WeakMap.t<unknown, contextParams> = Utils.WeakMap.make()
+
+let effectContextPrototype = %raw(`Object.create(null)`)
+Utils.Object.defineProperty(
+  effectContextPrototype,
+  "log",
+  {
+    get: () => {
+      (paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))).item->Logging.getUserLogger
+    },
+  },
+)
+%%raw(`
+var EffectContext = function(params, defaultShouldCache, callEffect) {
+  paramsByThis.set(this, params);
+  this.effect = callEffect;
+  this.cache = defaultShouldCache;
+};
+EffectContext.prototype = effectContextPrototype;
+`)
+
+@new
+external makeEffectContext: (
+  contextParams,
+  ~defaultShouldCache: bool,
+  ~callEffect: (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>,
+) => Internal.effectContext = "EffectContext"
+
+let initEffect = (params: contextParams) => {
+  let rec callEffect = (effect: Internal.effect, input: Internal.effectInput) => {
+    let effectContext = makeEffectContext(
+      params,
+      ~defaultShouldCache=effect.defaultShouldCache,
+      ~callEffect,
+    )
+    let effectArgs: Internal.effectArgs = {
+      input,
+      context: effectContext,
+      cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+    }
+    LoadLayer.loadEffect(
+      ~loadManager=params.loadManager,
+      ~persistence=params.persistence,
+      ~effect,
+      ~effectArgs,
+      ~inMemoryStore=params.inMemoryStore,
+      ~shouldGroup=params.isPreload,
+      ~item=params.item,
+    )
+  }
+  callEffect
+}
+
+type entityContextParams = {
+  ...contextParams,
+  entityConfig: Internal.entityConfig,
+}
+
+let getWhereTraps: Utils.Proxy.traps<entityContextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let entityConfig = params.entityConfig
+    if prop->Js.typeof !== "string" {
+      Js.Exn.raiseError(
+        `Invalid context.${entityConfig.name}.getWhere access by a non-string property.`,
+      )
+    } else {
+      let dbFieldName = prop->(Utils.magic: unknown => string)
+      switch entityConfig.table->Table.getFieldByDbName(dbFieldName) {
+      | None =>
+        Js.Exn.raiseError(
+          `Invalid context.${entityConfig.name}.getWhere.${dbFieldName} - the field doesn't exist. ${codegenHelpMessage}`,
+        )
+      | Some(field) =>
+        let fieldValueSchema = switch field {
+        | Field({fieldSchema}) => fieldSchema
+        | DerivedFrom(_) => S.string->S.toUnknown
+        }
+        {
+          Envio.eq: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Eq,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+          gt: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Gt,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+          lt: fieldValue =>
+            LoadLayer.loadByField(
+              ~loadManager=params.loadManager,
+              ~persistence=params.persistence,
+              ~operator=Lt,
+              ~entityConfig,
+              ~fieldName=dbFieldName,
+              ~fieldValueSchema,
+              ~inMemoryStore=params.inMemoryStore,
+              ~shouldGroup=params.isPreload,
+              ~item=params.item,
+              ~fieldValue,
+            ),
+        }->Utils.magic
+      }
+    }
+  },
+}
+
+let noopSet = (_entity: Internal.entity) => ()
+let noopDeleteUnsafe = (_entityId: string) => ()
+
+let entityTraps: Utils.Proxy.traps<entityContextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+
+    let set = params.isPreload
+      ? noopSet
+      : (entity: Internal.entity) => {
+          params.inMemoryStore
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryTable.Entity.set(
+            Set({
+              entityId: entity.id,
+              checkpointId: params.checkpointId,
+              entity,
+            }),
+            ~shouldSaveHistory=params.shouldSaveHistory,
+          )
+        }
+
+    switch prop {
+    | "get" =>
+      (
+        entityId =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId,
+          )
+      )->Utils.magic
+    | "getWhere" => params->Utils.Proxy.make(getWhereTraps)->Utils.magic
+    | "getOrThrow" =>
+      (
+        (entityId, ~message=?) =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId,
+          )->Promise.thenResolve(entity => {
+            switch entity {
+            | Some(entity) => entity
+            | None =>
+              Js.Exn.raiseError(
+                message->Belt.Option.getWithDefault(
+                  `Entity '${params.entityConfig.name}' with ID '${entityId}' is expected to exist.`,
+                ),
+              )
+            }
+          })
+      )->Utils.magic
+    | "getOrCreate" =>
+      (
+        (entity: Internal.entity) =>
+          LoadLayer.loadById(
+            ~loadManager=params.loadManager,
+            ~persistence=params.persistence,
+            ~entityConfig=params.entityConfig,
+            ~inMemoryStore=params.inMemoryStore,
+            ~shouldGroup=params.isPreload,
+            ~item=params.item,
+            ~entityId=entity.id,
+          )->Promise.thenResolve(storageEntity => {
+            switch storageEntity {
+            | Some(entity) => entity
+            | None => {
+                set(entity)
+                entity
+              }
+            }
+          })
+      )->Utils.magic
+    | "set" => set->Utils.magic
+    | "deleteUnsafe" =>
+      if params.isPreload {
+        noopDeleteUnsafe
+      } else {
+        entityId => {
+          params.inMemoryStore
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryTable.Entity.set(
+            Delete({
+              entityId,
+              checkpointId: params.checkpointId,
+            }),
+            ~shouldSaveHistory=params.shouldSaveHistory,
+          )
+        }
+      }->Utils.magic
+    | _ => Js.Exn.raiseError(`Invalid context.${params.entityConfig.name}.${prop} operation.`)
+    }
+  },
+}
+
+let handlerTraps: Utils.Proxy.traps<contextParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    if params.isResolved {
+      Utils.Error.make(
+        `Impossible to access context.${prop} after the handler is resolved. Make sure you didn't miss an await in the handler.`,
+      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+    }
+    switch prop {
+    | "log" =>
+      (params.isPreload ? Logging.noopLogger : params.item->Logging.getUserLogger)->Utils.magic
+    | "effect" =>
+      initEffect((params :> contextParams))->(
+        Utils.magic: (
+          (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>
+        ) => unknown
+      )
+
+    | "isPreload" => params.isPreload->Utils.magic
+    | "chain" =>
+      let chainId = params.item->Internal.getItemChainId
+      params.chains->Utils.Dict.dangerouslyGetByIntNonOption(chainId)->Utils.magic
+    | _ =>
+      switch params.config.userEntitiesByName->Utils.Dict.dangerouslyGetNonOption(prop) {
+      | Some(entityConfig) =>
+        {
+          item: params.item,
+          isPreload: params.isPreload,
+          inMemoryStore: params.inMemoryStore,
+          loadManager: params.loadManager,
+          persistence: params.persistence,
+          shouldSaveHistory: params.shouldSaveHistory,
+          checkpointId: params.checkpointId,
+          chains: params.chains,
+          isResolved: params.isResolved,
+          config: params.config,
+          entityConfig,
+        }
+        ->Utils.Proxy.make(entityTraps)
+        ->Utils.magic
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getHandlerContext = (params: contextParams): Internal.handlerContext => {
+  params->Utils.Proxy.make(handlerTraps)->Utils.magic
+}
+
+// Contract register context creation
+type contractRegisterParams = {
+  item: Internal.item,
+  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
+  config: Config.t,
+  mutable isResolved: bool,
+}
+
+let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    if params.isResolved {
+      Utils.Error.make(
+        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
+      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+    }
+    switch prop {
+    | "log" => params.item->Logging.getUserLogger->Utils.magic
+    | _ =>
+      // Use the pre-built mapping for efficient lookup
+      switch params.config.addContractNameToContractNameMapping->Utils.Dict.dangerouslyGetNonOption(
+        prop,
+      ) {
+      | Some(contractName) => {
+          let addFunction = (contractAddress: Address.t) => {
+            let validatedAddress = if params.config.ecosystem.name === Evm {
+              // The value is passed from the user-land,
+              // so we need to validate and checksum/lowercase the address.
+              if params.config.lowercaseAddresses {
+                contractAddress->Address.Evm.fromAddressLowercaseOrThrow
+              } else {
+                contractAddress->Address.Evm.fromAddressOrThrow
+              }
+            } else {
+              // TODO: Ideally we should do the same for other ecosystems
+              contractAddress
+            }
+
+            params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
+          }
+
+          addFunction->Utils.magic
+        }
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getContractRegisterContext = (params: contractRegisterParams) => {
+  params
+  ->Utils.Proxy.make(contractRegisterTraps)
+  ->Utils.magic
+}
+
+let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
+  event: (params.item->Internal.castUnsafeEventItem).event,
+  context: getContractRegisterContext(params),
+}