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

package/src/UserContext.res

@@ -0,0 +1,424 @@
+let codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`
+
+type contextParams = {
+  item: Internal.item,
+  checkpointId: Internal.checkpointId,
+  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 getWhereHandler = (params: entityContextParams, filter: Js.Dict.t<Js.Dict.t<unknown>>) => {
+  let entityConfig = params.entityConfig
+  let filterKeys = filter->Js.Dict.keys
+
+  if filterKeys->Array.length === 0 {
+    Js.Exn.raiseError(
+      `Empty filter passed to context.${entityConfig.name}.getWhere(). Please provide a filter like { fieldName: { _eq: value } }.`,
+    )
+  }
+  if filterKeys->Array.length > 1 {
+    Js.Exn.raiseError(
+      `Multiple filter fields passed to context.${entityConfig.name}.getWhere(). Currently only one filter field per call is supported. Received fields: ${filterKeys->Js.Array2.joinWith(
+          ", ",
+        )}.`,
+    )
+  }
+
+  let dbFieldName = filterKeys->Js.Array2.unsafe_get(0)
+  let operatorObj = filter->Js.Dict.unsafeGet(dbFieldName)
+  let operatorKeys = operatorObj->Js.Dict.keys
+
+  if operatorKeys->Array.length === 0 {
+    Js.Exn.raiseError(
+      `Empty operator passed to context.${entityConfig.name}.getWhere({ ${dbFieldName}: {} }). Please provide an operator like { _eq: value }, { _gt: value }, { _lt: value }, { _gte: value }, { _lte: value }, or { _in: [values] }.`,
+    )
+  }
+  if operatorKeys->Array.length > 1 {
+    Js.Exn.raiseError(
+      `Multiple operators passed to context.${entityConfig.name}.getWhere({ ${dbFieldName}: ... }). Currently only one operator per filter field is supported. Received operators: ${operatorKeys->Js.Array2.joinWith(
+          ", ",
+        )}.`,
+    )
+  }
+
+  let operatorKey = operatorKeys->Js.Array2.unsafe_get(0)
+
+  let fieldSchema = switch entityConfig.table->Table.getFieldByDbName(dbFieldName) {
+  | None =>
+    Js.Exn.raiseError(
+      `Invalid field "${dbFieldName}" in context.${entityConfig.name}.getWhere(). The field doesn't exist. ${codegenHelpMessage}`,
+    )
+  | Some(DerivedFrom(_)) =>
+    Js.Exn.raiseError(
+      `The field "${dbFieldName}" on entity "${entityConfig.name}" is a derived field and cannot be used in getWhere(). Use the source entity's indexed field instead.`,
+    )
+  | Some(Field({isIndex: false, linkedEntity: None})) =>
+    Js.Exn.raiseError(
+      `The field "${dbFieldName}" on entity "${entityConfig.name}" does not have an index. To use it in getWhere(), add the @index directive in your schema.graphql:\n\n  ${dbFieldName}: ... @index\n\nThen run 'pnpm envio codegen' to regenerate.`,
+    )
+  | Some(Field({fieldSchema})) => fieldSchema
+  }
+
+  if operatorKey === "_in" {
+    let fieldValues =
+      operatorObj
+      ->Js.Dict.unsafeGet(operatorKey)
+      ->(Utils.magic: unknown => array<unknown>)
+
+    fieldValues
+    ->Js.Array2.map(fieldValue =>
+      LoadLayer.loadByField(
+        ~loadManager=params.loadManager,
+        ~persistence=params.persistence,
+        ~operator=Eq,
+        ~entityConfig,
+        ~fieldName=dbFieldName,
+        ~fieldValueSchema=fieldSchema,
+        ~inMemoryStore=params.inMemoryStore,
+        ~shouldGroup=params.isPreload,
+        ~item=params.item,
+        ~fieldValue,
+      )
+    )
+    ->Promise.all
+    ->Promise.thenResolve(results => results->Belt.Array.concatMany)
+  } else if operatorKey === "_gte" || operatorKey === "_lte" {
+    // _gte and _lte are composed from Eq + Gt/Lt
+    let rangeOperator: TableIndices.Operator.t = operatorKey === "_gte" ? Gt : Lt
+    let fieldValue = operatorObj->Js.Dict.unsafeGet(operatorKey)
+
+    let loadWithOperator = operator =>
+      LoadLayer.loadByField(
+        ~loadManager=params.loadManager,
+        ~persistence=params.persistence,
+        ~operator,
+        ~entityConfig,
+        ~fieldName=dbFieldName,
+        ~fieldValueSchema=fieldSchema,
+        ~inMemoryStore=params.inMemoryStore,
+        ~shouldGroup=params.isPreload,
+        ~item=params.item,
+        ~fieldValue,
+      )
+
+    [loadWithOperator(Eq), loadWithOperator(rangeOperator)]
+    ->Promise.all
+    ->Promise.thenResolve(results => results->Belt.Array.concatMany)
+  } else {
+    let operator: TableIndices.Operator.t = switch operatorKey {
+    | "_eq" => Eq
+    | "_gt" => Gt
+    | "_lt" => Lt
+    | _ =>
+      Js.Exn.raiseError(
+        `Invalid operator "${operatorKey}" in context.${entityConfig.name}.getWhere({ ${dbFieldName}: { ${operatorKey}: ... } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`,
+      )
+    }
+
+    let fieldValue = operatorObj->Js.Dict.unsafeGet(operatorKey)
+
+    LoadLayer.loadByField(
+      ~loadManager=params.loadManager,
+      ~persistence=params.persistence,
+      ~operator,
+      ~entityConfig,
+      ~fieldName=dbFieldName,
+      ~fieldValueSchema=fieldSchema,
+      ~inMemoryStore=params.inMemoryStore,
+      ~shouldGroup=params.isPreload,
+      ~item=params.item,
+      ~fieldValue,
+    )
+  }
+}
+
+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: (string => promise<option<Internal.entity>>) => unknown)
+    | "getWhere" =>
+      (
+        filter =>
+          getWhereHandler(params, filter->(Utils.magic: unknown => Js.Dict.t<Js.Dict.t<unknown>>))
+      )->(Utils.magic: (unknown => promise<array<Internal.entity>>) => unknown)
+    | "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: ((string, ~message: string=?) => promise<Internal.entity>) => unknown)
+    | "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: (Internal.entity => promise<Internal.entity>) => unknown)
+    | "set" => set->(Utils.magic: (Internal.entity => unit) => unknown)
+    | "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: (string => unit) => unknown)
+    | _ => 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: Envio.logger => unknown
+      )
+
+    | "effect" =>
+      initEffect((params :> contextParams))->(
+        Utils.magic: (
+          (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>
+        ) => unknown
+      )
+
+    | "isPreload" => params.isPreload->(Utils.magic: bool => unknown)
+    | "chain" =>
+      let chainId = params.item->Internal.getItemChainId
+      params.chains
+      ->Utils.Dict.dangerouslyGetByIntNonOption(chainId)
+      ->(Utils.magic: option<Internal.chainInfo> => unknown)
+    | _ =>
+      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: entityContextParams => unknown)
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getHandlerContext = (params: contextParams): Internal.handlerContext => {
+  params->Utils.Proxy.make(handlerTraps)->(Utils.magic: contextParams => Internal.handlerContext)
+}
+
+// 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: Envio.logger => unknown)
+    | _ =>
+      // 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: (Address.t => unit) => unknown)
+        }
+      | None =>
+        Js.Exn.raiseError(`Invalid context access by '${prop}' property. ${codegenHelpMessage}`)
+      }
+    }
+  },
+}
+
+let getContractRegisterContext = (params: contractRegisterParams) => {
+  params
+  ->Utils.Proxy.make(contractRegisterTraps)
+  ->(Utils.magic: contractRegisterParams => Internal.contractRegisterContext)
+}
+
+let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
+  event: (params.item->Internal.castUnsafeEventItem).event,
+  context: getContractRegisterContext(params),
+}

package/src/UserContext.res.mjs

@@ -0,0 +1,279 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./db/Table.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Address from "./Address.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
+import * as LoadLayer from "./LoadLayer.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var codegenHelpMessage = "Rerun 'pnpm dev' to update generated code after schema.graphql changes.";
+
+var paramsByThis = new WeakMap();
+
+var effectContextPrototype = (Object.create(null));
+
+Object.defineProperty(effectContextPrototype, "log", {
+      get: (function () {
+          return Logging.getUserLogger(paramsByThis.get(this).item);
+        })
+    });
+
+var EffectContext = function(params, defaultShouldCache, callEffect) {
+  paramsByThis.set(this, params);
+  this.effect = callEffect;
+  this.cache = defaultShouldCache;
+};
+EffectContext.prototype = effectContextPrototype;
+;
+
+function initEffect(params) {
+  var callEffect = function (effect, input) {
+    var effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
+    var effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    var effectArgs = {
+      input: input,
+      context: effectContext,
+      cacheKey: effectArgs_cacheKey
+    };
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
+  };
+  return callEffect;
+}
+
+function getWhereHandler(params, filter) {
+  var entityConfig = params.entityConfig;
+  var filterKeys = Object.keys(filter);
+  if (filterKeys.length === 0) {
+    Js_exn.raiseError("Empty filter passed to context." + entityConfig.name + ".getWhere(). Please provide a filter like { fieldName: { _eq: value } }.");
+  }
+  if (filterKeys.length > 1) {
+    Js_exn.raiseError("Multiple filter fields passed to context." + entityConfig.name + ".getWhere(). Currently only one filter field per call is supported. Received fields: " + filterKeys.join(", ") + ".");
+  }
+  var dbFieldName = filterKeys[0];
+  var operatorObj = filter[dbFieldName];
+  var operatorKeys = Object.keys(operatorObj);
+  if (operatorKeys.length === 0) {
+    Js_exn.raiseError("Empty operator passed to context." + entityConfig.name + ".getWhere({ " + dbFieldName + ": {} }). Please provide an operator like { _eq: value }, { _gt: value }, { _lt: value }, { _gte: value }, { _lte: value }, or { _in: [values] }.");
+  }
+  if (operatorKeys.length > 1) {
+    Js_exn.raiseError("Multiple operators passed to context." + entityConfig.name + ".getWhere({ " + dbFieldName + ": ... }). Currently only one operator per filter field is supported. Received operators: " + operatorKeys.join(", ") + ".");
+  }
+  var operatorKey = operatorKeys[0];
+  var match = Table.getFieldByDbName(entityConfig.table, dbFieldName);
+  var fieldSchema;
+  if (match !== undefined) {
+    if (match.TAG === "Field") {
+      var match$1 = match._0;
+      fieldSchema = match$1.isIndex || match$1.linkedEntity !== undefined ? match$1.fieldSchema : Js_exn.raiseError("The field \"" + dbFieldName + "\" on entity \"" + entityConfig.name + "\" does not have an index. To use it in getWhere(), add the @index directive in your schema.graphql:\n\n  " + dbFieldName + ": ... @index\n\nThen run 'pnpm envio codegen' to regenerate.");
+    } else {
+      fieldSchema = Js_exn.raiseError("The field \"" + dbFieldName + "\" on entity \"" + entityConfig.name + "\" is a derived field and cannot be used in getWhere(). Use the source entity's indexed field instead.");
+    }
+  } else {
+    fieldSchema = Js_exn.raiseError("Invalid field \"" + dbFieldName + "\" in context." + entityConfig.name + ".getWhere(). The field doesn't exist. " + codegenHelpMessage);
+  }
+  if (operatorKey === "_in") {
+    var fieldValues = operatorObj[operatorKey];
+    return Promise.all(fieldValues.map(function (fieldValue) {
+                      return LoadLayer.loadByField(params.loadManager, params.persistence, "Eq", entityConfig, params.inMemoryStore, dbFieldName, fieldSchema, params.isPreload, params.item, fieldValue);
+                    })).then(Belt_Array.concatMany);
+  }
+  if (operatorKey === "_gte" || operatorKey === "_lte") {
+    var rangeOperator = operatorKey === "_gte" ? "Gt" : "Lt";
+    var fieldValue = operatorObj[operatorKey];
+    var loadWithOperator = function (operator) {
+      return LoadLayer.loadByField(params.loadManager, params.persistence, operator, entityConfig, params.inMemoryStore, dbFieldName, fieldSchema, params.isPreload, params.item, fieldValue);
+    };
+    return Promise.all([
+                  loadWithOperator("Eq"),
+                  loadWithOperator(rangeOperator)
+                ]).then(Belt_Array.concatMany);
+  }
+  var operator;
+  switch (operatorKey) {
+    case "_eq" :
+        operator = "Eq";
+        break;
+    case "_gt" :
+        operator = "Gt";
+        break;
+    case "_lt" :
+        operator = "Lt";
+        break;
+    default:
+      operator = Js_exn.raiseError("Invalid operator \"" + operatorKey + "\" in context." + entityConfig.name + ".getWhere({ " + dbFieldName + ": { " + operatorKey + ": ... } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.");
+  }
+  var fieldValue$1 = operatorObj[operatorKey];
+  return LoadLayer.loadByField(params.loadManager, params.persistence, operator, entityConfig, params.inMemoryStore, dbFieldName, fieldSchema, params.isPreload, params.item, fieldValue$1);
+}
+
+function noopSet(_entity) {
+  
+}
+
+function noopDeleteUnsafe(_entityId) {
+  
+}
+
+var entityTraps = {
+  get: (function (params, prop) {
+      var set = params.isPreload ? noopSet : (function (entity) {
+            InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                  type: "SET",
+                  entityId: entity.id,
+                  entity: entity,
+                  checkpointId: params.checkpointId
+                }, params.shouldSaveHistory, undefined);
+          });
+      switch (prop) {
+        case "deleteUnsafe" :
+            if (params.isPreload) {
+              return noopDeleteUnsafe;
+            } else {
+              return function (entityId) {
+                InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                      type: "DELETE",
+                      entityId: entityId,
+                      checkpointId: params.checkpointId
+                    }, params.shouldSaveHistory, undefined);
+              };
+            }
+        case "get" :
+            return function (entityId) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+            };
+        case "getOrCreate" :
+            return function (entity) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(function (storageEntity) {
+                          if (storageEntity !== undefined) {
+                            return storageEntity;
+                          } else {
+                            set(entity);
+                            return entity;
+                          }
+                        });
+            };
+        case "getOrThrow" :
+            return function (entityId, message) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(function (entity) {
+                          if (entity !== undefined) {
+                            return entity;
+                          } else {
+                            return Js_exn.raiseError(Belt_Option.getWithDefault(message, "Entity '" + params.entityConfig.name + "' with ID '" + entityId + "' is expected to exist."));
+                          }
+                        });
+            };
+        case "getWhere" :
+            return function (filter) {
+              return getWhereHandler(params, filter);
+            };
+        case "set" :
+            return set;
+        default:
+          return Js_exn.raiseError("Invalid context." + params.entityConfig.name + "." + prop + " operation.");
+      }
+    })
+};
+
+var handlerTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the handler is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      switch (prop) {
+        case "chain" :
+            var chainId = Internal.getItemChainId(params.item);
+            return params.chains[chainId];
+        case "effect" :
+            return initEffect(params);
+        case "isPreload" :
+            return params.isPreload;
+        case "log" :
+            if (params.isPreload) {
+              return Logging.noopLogger;
+            } else {
+              return Logging.getUserLogger(params.item);
+            }
+        default:
+          var entityConfig = params.config.userEntitiesByName[prop];
+          if (entityConfig !== undefined) {
+            return new Proxy({
+                        item: params.item,
+                        checkpointId: params.checkpointId,
+                        inMemoryStore: params.inMemoryStore,
+                        loadManager: params.loadManager,
+                        persistence: params.persistence,
+                        isPreload: params.isPreload,
+                        shouldSaveHistory: params.shouldSaveHistory,
+                        chains: params.chains,
+                        config: params.config,
+                        isResolved: params.isResolved,
+                        entityConfig: entityConfig
+                      }, entityTraps);
+          } else {
+            return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+          }
+      }
+    })
+};
+
+function getHandlerContext(params) {
+  return new Proxy(params, handlerTraps);
+}
+
+var contractRegisterTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the contract register is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      if (prop === "log") {
+        return Logging.getUserLogger(params.item);
+      }
+      var contractName = params.config.addContractNameToContractNameMapping[prop];
+      if (contractName !== undefined) {
+        return function (contractAddress) {
+          var validatedAddress = params.config.ecosystem.name === "evm" ? (
+              params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
+            ) : contractAddress;
+          params.onRegister(params.item, validatedAddress, contractName);
+        };
+      } else {
+        return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+      }
+    })
+};
+
+function getContractRegisterContext(params) {
+  return new Proxy(params, contractRegisterTraps);
+}
+
+function getContractRegisterArgs(params) {
+  return {
+          event: params.item.event,
+          context: new Proxy(params, contractRegisterTraps)
+        };
+}
+
+export {
+  codegenHelpMessage ,
+  paramsByThis ,
+  effectContextPrototype ,
+  initEffect ,
+  getWhereHandler ,
+  noopSet ,
+  noopDeleteUnsafe ,
+  entityTraps ,
+  handlerTraps ,
+  getHandlerContext ,
+  contractRegisterTraps ,
+  getContractRegisterContext ,
+  getContractRegisterArgs ,
+}
+/* paramsByThis Not a pure module */