envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/UserContext.res.mjs

@@ -2,29 +2,28 @@
 
 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 ChainMap from "./ChainMap.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 Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Belt_Option from "@rescript/runtime/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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-var codegenHelpMessage = "Rerun 'pnpm dev' to update generated code after schema.graphql changes.";
+let codegenHelpMessage = `Rerun 'pnpm dev' to update generated code after schema.graphql changes.`;
 
-var paramsByThis = new WeakMap();
+let paramsByThis = new WeakMap();
 
-var effectContextPrototype = (Object.create(null));
+let effectContextPrototype = (Object.create(null));
 
 Object.defineProperty(effectContextPrototype, "log", {
-      get: (function () {
-          return Logging.getUserLogger(paramsByThis.get(this).item);
-        })
-    });
+  get: () => Logging.getUserLogger(paramsByThis.get(this).item)
+});
 
 var EffectContext = function(params, defaultShouldCache, callEffect) {
   paramsByThis.set(this, params);
@@ -35,10 +34,10 @@ 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 = {
+  let callEffect = (effect, input) => {
+    let effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
+    let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    let effectArgs = {
       input: input,
       context: effectContext,
       cacheKey: effectArgs_cacheKey
@@ -49,68 +48,64 @@ function initEffect(params) {
 }
 
 function getWhereHandler(params, filter) {
-  var entityConfig = params.entityConfig;
-  var filterKeys = Object.keys(filter);
+  let entityConfig = params.entityConfig;
+  let 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 } }.");
+    Stdlib_JsError.throwWithMessage(`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(", ") + ".");
+    Stdlib_JsError.throwWithMessage(`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);
+  let dbFieldName = filterKeys[0];
+  let operatorObj = filter[dbFieldName];
+  let 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] }.");
+    Stdlib_JsError.throwWithMessage(`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(", ") + ".");
+    Stdlib_JsError.throwWithMessage(`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;
+  let operatorKey = operatorKeys[0];
+  let match = Table.getFieldByDbName(entityConfig.table, dbFieldName);
+  let 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.");
+      let match$1 = match._0;
+      fieldSchema = match$1.isIndex || match$1.linkedEntity !== undefined ? match$1.fieldSchema : Stdlib_JsError.throwWithMessage(`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.");
+      fieldSchema = Stdlib_JsError.throwWithMessage(`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);
+    fieldSchema = Stdlib_JsError.throwWithMessage(`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);
+    let fieldValues = operatorObj[operatorKey];
+    return Promise.all(fieldValues.map(fieldValue => 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);
-    };
+    let rangeOperator = operatorKey === "_gte" ? "Gt" : "Lt";
+    let fieldValue = operatorObj[operatorKey];
+    let loadWithOperator = operator => 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);
+      loadWithOperator("Eq"),
+      loadWithOperator(rangeOperator)
+    ]).then(Belt_Array.concatMany);
   }
-  var operator;
+  let operator;
   switch (operatorKey) {
     case "_eq" :
-        operator = "Eq";
-        break;
+      operator = "Eq";
+      break;
     case "_gt" :
-        operator = "Gt";
-        break;
+      operator = "Gt";
+      break;
     case "_lt" :
-        operator = "Lt";
-        break;
+      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.");
+      operator = Stdlib_JsError.throwWithMessage(`Invalid operator "` + operatorKey + `" in context.` + entityConfig.name + `.getWhere({ ` + dbFieldName + `: { ` + operatorKey + `: ... } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
   }
-  var fieldValue$1 = operatorObj[operatorKey];
+  let fieldValue$1 = operatorObj[operatorKey];
   return LoadLayer.loadByField(params.loadManager, params.persistence, operator, entityConfig, params.inMemoryStore, dbFieldName, fieldSchema, params.isPreload, params.item, fieldValue$1);
 }
 
@@ -122,132 +117,150 @@ 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.");
+let entityTraps_get = (params, prop) => {
+  let set = params.isPreload ? noopSet : 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 entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+          type: "DELETE",
+          entityId: entityId,
+          checkpointId: params.checkpointId
+        }, params.shouldSaveHistory, undefined);
       }
-    })
+    case "get" :
+      return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+    case "getOrCreate" :
+      return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(storageEntity => {
+        if (storageEntity !== undefined) {
+          return storageEntity;
+        } else {
+          set(entity);
+          return entity;
+        }
+      });
+    case "getOrThrow" :
+      return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(entity => {
+        if (entity !== undefined) {
+          return entity;
+        } else {
+          return Stdlib_JsError.throwWithMessage(Belt_Option.getWithDefault(message, `Entity '` + params.entityConfig.name + `' with ID '` + entityId + `' is expected to exist.`));
+        }
+      });
+    case "getWhere" :
+      return filter => getWhereHandler(params, filter);
+    case "set" :
+      return set;
+    default:
+      return Stdlib_JsError.throwWithMessage(`Invalid context.` + params.entityConfig.name + `.` + prop + ` operation.`);
+  }
+};
+
+let entityTraps = {
+  get: entityTraps_get
 };
 
-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."));
+let handlerTraps_get = (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" :
+      let 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);
       }
-      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);
-          }
+    default:
+      let 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 Stdlib_JsError.throwWithMessage(`Invalid context access by '` + prop + `' property. ` + codegenHelpMessage);
       }
-    })
+  }
+};
+
+let handlerTraps = {
+  get: handlerTraps_get
 };
 
 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 makeAddFunction(params, contractName) {
+  return contractAddress => {
+    if (params.isResolved) {
+      ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
+    }
+    let validatedAddress = params.config.ecosystem.name === "evm" ? (
+        params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
+      ) : contractAddress;
+    params.onRegister(params.item, validatedAddress, contractName);
+  };
+}
+
+let contractRegisterChainTraps_get = (params, prop) => {
+  if (prop === "id") {
+    return params.item.chain;
+  }
+  let isValidContract = ChainMap.values(params.config.chainMap).some(chain => chain.contracts.some(c => c.name === prop));
+  if (isValidContract) {
+    return {
+      add: makeAddFunction(params, prop)
+    };
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Invalid contract name '` + prop + `' on context.chain. ` + codegenHelpMessage);
+  }
+};
+
+let contractRegisterChainTraps = {
+  get: contractRegisterChainTraps_get
+};
+
+let contractRegisterTraps_get = (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.`));
+  }
+  switch (prop) {
+    case "chain" :
+      return new Proxy(params, contractRegisterChainTraps);
+    case "log" :
+      return Logging.getUserLogger(params.item);
+    default:
+      return Stdlib_JsError.throwWithMessage(`Invalid context access by '` + prop + `' property. Use context.chain.ContractName.add(address) to register contracts. ` + codegenHelpMessage);
+  }
+};
+
+let contractRegisterTraps = {
+  get: contractRegisterTraps_get
 };
 
 function getContractRegisterContext(params) {
@@ -256,24 +269,26 @@ function getContractRegisterContext(params) {
 
 function getContractRegisterArgs(params) {
   return {
-          event: params.item.event,
-          context: new Proxy(params, contractRegisterTraps)
-        };
+    event: params.item.event,
+    context: new Proxy(params, contractRegisterTraps)
+  };
 }
 
 export {
-  codegenHelpMessage ,
-  paramsByThis ,
-  effectContextPrototype ,
-  initEffect ,
-  getWhereHandler ,
-  noopSet ,
-  noopDeleteUnsafe ,
-  entityTraps ,
-  handlerTraps ,
-  getHandlerContext ,
-  contractRegisterTraps ,
-  getContractRegisterContext ,
-  getContractRegisterArgs ,
+  codegenHelpMessage,
+  paramsByThis,
+  effectContextPrototype,
+  initEffect,
+  getWhereHandler,
+  noopSet,
+  noopDeleteUnsafe,
+  entityTraps,
+  handlerTraps,
+  getHandlerContext,
+  makeAddFunction,
+  contractRegisterChainTraps,
+  contractRegisterTraps,
+  getContractRegisterContext,
+  getContractRegisterArgs,
 }
 /* paramsByThis Not a pure module */