envio 3.1.2 → 3.2.0

package/src/GlobalStateManager.res

@@ -1,67 +1,57 @@
-module type State = {
-  type t
-  type action
-  type task
-
-  let taskReducer: (t, task, ~dispatchAction: action => unit) => promise<unit>
-  let actionReducer: (t, action) => (t, array<task>)
-  let invalidatedActionReducer: (t, action) => (t, array<task>)
-  let getId: t => int
+type t = {
+  mutable state: GlobalState.t,
+  onError: exn => unit,
+  reducers: GlobalState.reducers,
 }
 
-module MakeManager = (S: State) => {
-  type t = {mutable state: S.t, onError: exn => unit}
-
-  let make = (
-    state: S.t,
-    ~onError=e => {
-      e->ErrorHandling.make(~msg="Indexer has failed with an unexpected error")->ErrorHandling.log
-      NodeJs.process->NodeJs.exitWithCode(Failure)
-    },
-  ) => {
-    state,
-    onError,
-  }
+let make = (
+  state: GlobalState.t,
+  ~reducers: GlobalState.reducers,
+  ~onError=e => {
+    e->ErrorHandling.make(~msg="Indexer has failed with an unexpected error")->ErrorHandling.log
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  },
+) => {
+  state,
+  onError,
+  reducers,
+}
 
-  let rec dispatchAction = (~stateId=0, self: t, action: S.action) => {
-    try {
-      let reducer = if stateId == self.state->S.getId {
-        S.actionReducer
-      } else {
-        S.invalidatedActionReducer
-      }
-      let (nextState, nextTasks) = reducer(self.state, action)
-      self.state = nextState
-      nextTasks->Array.forEach(task => dispatchTask(self, task))
-    } catch {
-    | e => e->self.onError
+let rec dispatchAction = (~stateId=0, self: t, action: GlobalState.action) => {
+  try {
+    let reducer = if stateId == self.state->GlobalState.getId {
+      self.reducers.actionReducer
+    } else {
+      self.reducers.invalidatedActionReducer
     }
+    let (nextState, nextTasks) = reducer(self.state, action)
+    self.state = nextState
+    nextTasks->Array.forEach(task => dispatchTask(self, task))
+  } catch {
+  | e => e->self.onError
   }
-  and dispatchTask = (self, task: S.task) => {
-    let stateId = self.state->S.getId
-    NodeJs.setImmediate(() => {
-      if stateId !== self.state->S.getId {
-        Logging.info("Invalidated task discarded")
-      } else {
-        try {
-          S.taskReducer(self.state, task, ~dispatchAction=action =>
-            dispatchAction(~stateId, self, action)
-          )
-          ->Promise.catch(e => {
-            e->self.onError
-            Promise.resolve()
-          })
-          ->ignore
-        } catch {
-        | e => e->self.onError
-        }
+}
+and dispatchTask = (self, task: GlobalState.task) => {
+  let stateId = self.state->GlobalState.getId
+  NodeJs.setImmediate(() => {
+    if stateId !== self.state->GlobalState.getId {
+      Logging.info("Invalidated task discarded")
+    } else {
+      try {
+        self.reducers.taskReducer(self.state, task, ~dispatchAction=action =>
+          dispatchAction(~stateId, self, action)
+        )
+        ->Promise.catch(e => {
+          e->self.onError
+          Promise.resolve()
+        })
+        ->ignore
+      } catch {
+      | e => e->self.onError
       }
-    })
-  }
-
-  let getState = self => self.state
-  let setState = (self: t, state: S.t) => self.state = state
+    }
+  })
 }
 
-module Manager = MakeManager(GlobalState)
-include Manager
+let getState = self => self.state
+let setState = (self: t, state: GlobalState.t) => self.state = state

package/src/GlobalStateManager.res.mjs

@@ -7,21 +7,22 @@ import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function make(state, onErrorOpt) {
+function make(state, reducers, onErrorOpt) {
   let onError = onErrorOpt !== undefined ? onErrorOpt : e => {
       ErrorHandling.log(ErrorHandling.make(e, undefined, "Indexer has failed with an unexpected error"));
       Process.exit(1);
     };
   return {
     state: state,
-    onError: onError
+    onError: onError,
+    reducers: reducers
   };
 }
 
 function dispatchAction(stateIdOpt, self, action) {
   let stateId = stateIdOpt !== undefined ? stateIdOpt : 0;
   try {
-    let reducer = stateId === GlobalState.getId(self.state) ? GlobalState.actionReducer : GlobalState.invalidatedActionReducer;
+    let reducer = stateId === GlobalState.getId(self.state) ? self.reducers.actionReducer : self.reducers.invalidatedActionReducer;
     let match = reducer(self.state, action);
     self.state = match[0];
     match[1].forEach(task => dispatchTask(self, task));
@@ -38,7 +39,7 @@ function dispatchTask(self, task) {
       return Logging.info("Invalidated task discarded");
     }
     try {
-      Stdlib_Promise.$$catch(GlobalState.taskReducer(self.state, task, action => dispatchAction(stateId, self, action)), e => {
+      Stdlib_Promise.$$catch(self.reducers.taskReducer(self.state, task, action => dispatchAction(stateId, self, action)), e => {
         self.onError(e);
         return Promise.resolve();
       });

package/src/GlobalStateManager.resi

@@ -1,6 +1,6 @@
 type t
 
-let make: (GlobalState.t, ~onError: exn => unit=?) => t
+let make: (GlobalState.t, ~reducers: GlobalState.reducers, ~onError: exn => unit=?) => t
 let dispatchAction: (~stateId: int=?, t, GlobalState.action) => unit
 let dispatchTask: (t, GlobalState.task) => unit
 let getState: t => GlobalState.t

package/src/HandlerLoader.res

@@ -143,7 +143,18 @@ let applyRegistrations = (~config: Config.t): Config.t => {
               dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
             } :> Internal.eventConfig)
           | Svm =>
-            JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`)
+            let svmEv =
+              ev->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+            ({
+              ...svmEv,
+              isWildcard,
+              handler,
+              contractRegister,
+              dependsOnAddresses: Internal.dependsOnAddresses(
+                ~isWildcard,
+                ~filterByAddresses=false,
+              ),
+            } :> Internal.eventConfig)
           }
         },
       )

package/src/HandlerLoader.res.mjs

@@ -110,7 +110,12 @@ function applyRegistrations(config) {
               kind: ev.kind
             };
           case "svm" :
-            return Stdlib_JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`);
+            let newrecord = {...ev};
+            newrecord.contractRegister = contractRegister;
+            newrecord.handler = handler;
+            newrecord.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
+            newrecord.isWildcard = isWildcard;
+            return newrecord;
         }
       });
       return {

package/src/HandlerRegister.res

@@ -89,7 +89,7 @@ let preRegistered = registry.preRegistered
 
 let withRegistration = (fn: activeRegistration => unit) => {
   switch activeRegistration.contents {
-  | None => preRegistered->Belt.Array.push(fn)
+  | None => preRegistered->Array.push(fn)
   | Some(r) =>
     if r.finished {
       JsError.throwWithMessage(
@@ -162,11 +162,11 @@ let registerOnBlock = (
 ) => {
   withRegistration(registration => {
     let onBlockByChainId = registration.registrations.onBlockByChainId
-    let key = chainId->Belt.Int.toString
+    let key = chainId->Int.toString
     let index =
       onBlockByChainId
       ->Utils.Dict.dangerouslyGetNonOption(key)
-      ->Belt.Option.mapWithDefault(0, configs => configs->Belt.Array.length)
+      ->Option.mapOr(0, configs => configs->Array.length)
     onBlockByChainId->Utils.Dict.push(
       key,
       (
@@ -190,16 +190,16 @@ let getContractRegister = (~contractName, ~eventName) =>
   get(~contractName, ~eventName).contractRegister
 
 let getOnEventWhere = (~contractName, ~eventName) =>
-  get(~contractName, ~eventName).eventOptions->Belt.Option.flatMap(value => value.where)
+  get(~contractName, ~eventName).eventOptions->Option.flatMap(value => value.where)
 
 let isWildcard = (~contractName, ~eventName) =>
   get(~contractName, ~eventName).eventOptions
-  ->Belt.Option.flatMap(value => value.wildcard)
-  ->Belt.Option.getWithDefault(false)
+  ->Option.flatMap(value => value.wildcard)
+  ->Option.getOr(false)
 
 let hasRegistration = (~contractName, ~eventName) => {
   let r = get(~contractName, ~eventName)
-  r.handler->Belt.Option.isSome || r.contractRegister->Belt.Option.isSome
+  r.handler->Option.isSome || r.contractRegister->Option.isSome
 }
 
 type eventNamespace = {contractName: string, eventName: string}
@@ -284,7 +284,7 @@ let setHandler = (
       )
     | Some(prevHandler) =>
       let incomingEventOptions =
-        eventOptions->Belt.Option.map(v =>
+        eventOptions->Option.map(v =>
           v->(Utils.magic: Internal.eventOptions<'where> => Internal.eventOptions<JSON.t>)
         )
       if eventOptionsMatch(t.eventOptions, incomingEventOptions) {
@@ -341,7 +341,7 @@ let setContractRegister = (
       )
     | Some(prevContractRegister) =>
       let incomingEventOptions =
-        eventOptions->Belt.Option.map(v =>
+        eventOptions->Option.map(v =>
           v->(Utils.magic: Internal.eventOptions<'where> => Internal.eventOptions<JSON.t>)
         )
       if eventOptionsMatch(t.eventOptions, incomingEventOptions) {

package/src/HandlerRegister.res.mjs

@@ -2,7 +2,7 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 
@@ -121,8 +121,8 @@ function throwIfFinishedRegistration(methodName) {
 function registerOnBlock(name, chainId, interval, startBlock, endBlock, handler) {
   withRegistration(registration => {
     let onBlockByChainId = registration.registrations.onBlockByChainId;
-    let key = String(chainId);
-    let index = Belt_Option.mapWithDefault(onBlockByChainId[key], 0, configs => configs.length);
+    let key = chainId.toString();
+    let index = Stdlib_Option.mapOr(onBlockByChainId[key], 0, configs => configs.length);
     Utils.Dict.push(onBlockByChainId, key, {
       index: index,
       name: name,
@@ -144,19 +144,19 @@ function getContractRegister(contractName, eventName) {
 }
 
 function getOnEventWhere(contractName, eventName) {
-  return Belt_Option.flatMap(get(contractName, eventName).eventOptions, value => value.where);
+  return Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.where);
 }
 
 function isWildcard(contractName, eventName) {
-  return Belt_Option.getWithDefault(Belt_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
 }
 
 function hasRegistration(contractName, eventName) {
   let r = get(contractName, eventName);
-  if (Belt_Option.isSome(r.handler)) {
+  if (Stdlib_Option.isSome(r.handler)) {
     return true;
   } else {
-    return Belt_Option.isSome(r.contractRegister);
+    return Stdlib_Option.isSome(r.contractRegister);
   }
 }
 
@@ -223,7 +223,7 @@ function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
     let t = get(contractName, eventName);
     let prevHandler = t.handler;
     if (prevHandler !== undefined) {
-      let incomingEventOptions = Belt_Option.map(eventOptions, v => v);
+      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
       if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
         return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
       }
@@ -253,7 +253,7 @@ function setContractRegister(contractName, eventName, contractRegister, eventOpt
     let t = get(contractName, eventName);
     let prevContractRegister = t.contractRegister;
     if (prevContractRegister !== undefined) {
-      let incomingEventOptions = Belt_Option.map(eventOptions, v => v);
+      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
       if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
         return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
       }

package/src/Hasura.res

@@ -40,6 +40,19 @@ let clearMetadataRoute = Rest.route(() => {
   responses,
 })
 
+let reloadMetadataRoute = Rest.route(() => {
+  method: Post,
+  path: "",
+  input: s => {
+    let _ = s.field("type", S.literal("reload_metadata"))
+    {
+      "args": s.field("args", S.json(~validate=false)),
+      "auth": s->auth,
+    }
+  },
+  responses,
+})
+
 let trackTablesRoute = Rest.route(() => {
   method: Post,
   path: "",
@@ -79,7 +92,7 @@ let sendOperation = async (~endpoint, ~auth, ~operation: JSON.t) => {
     } catch {
     | exn =>
       if attempt < maxRetries {
-        let backoffMs = Math.pow(2.0, ~exp=attempt->Belt.Int.toFloat)->Belt.Float.toInt * 1000
+        let backoffMs = Math.pow(2.0, ~exp=attempt->Int.toFloat)->Float.toInt * 1000
         await Time.resolvePromiseAfterDelay(~delayMilliseconds=backoffMs)
         await retry(~attempt=attempt + 1)
       } else {
@@ -110,10 +123,63 @@ let clearHasuraMetadata = async (~endpoint, ~auth) => {
   }
 }
 
+let reloadHasuraMetadata = async (~endpoint, ~auth) => {
+  try {
+    let result = await reloadMetadataRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "args": {
+          "reload_sources": ["default"],
+        }->(Utils.magic: 'a => JSON.t),
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => "Hasura metadata reloaded"
+    | AlreadyDone => "Hasura metadata reload acknowledged"
+    }
+    Logging.trace(msg)
+  } catch {
+  | exn =>
+    Logging.error({
+      "msg": `There was an issue reloading hasura metadata - table tracking may race with schema creation.`,
+      "err": exn->Utils.prettifyExn,
+    })
+  }
+}
+
+type columnConfig = {
+  // The GraphQL field name exposed by Hasura, when it differs from the
+  // column name in the database (eg with `column_name_format: snake_case`).
+  customName: option<string>,
+  comment: option<string>,
+}
+
 type trackTableConfig = {
   tableName: string,
   description: option<string>,
-  columnDescriptions: dict<string>,
+  // Keyed by db column name
+  columnConfigs: dict<columnConfig>,
+}
+
+let makeColumnConfigs = (table: Table.table): dict<columnConfig> => {
+  let columnConfigs = dict{}
+  table.fields->Array.forEach(fieldOrDerived =>
+    switch fieldOrDerived {
+    | Table.Field(field) => {
+        let apiFieldName = field->Table.getApiFieldName
+        let dbFieldName = field->Table.getPgDbFieldName
+        // Expose renamed columns in GraphQL under the original field name
+        let customName = apiFieldName === dbFieldName ? None : Some(apiFieldName)
+        switch (customName, field.description) {
+        | (None, None) => ()
+        | (customName, comment) => columnConfigs->Dict.set(dbFieldName, {customName, comment})
+        }
+      }
+    | Table.DerivedFrom(_) => ()
+    }
+  )
+  columnConfigs
 }
 
 let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableConfigs: array<trackTableConfig>) => {
@@ -124,7 +190,7 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableConfigs: array<track
         "args": {
           // If set to false, any warnings will cause the API call to fail and no new tables to be tracked. Otherwise tables that fail to track will be raised as warnings. (default: true)
           "allow_warnings": false,
-          "tables": tableConfigs->Array.map(({tableName, description, columnDescriptions}) => {
+          "tables": tableConfigs->Array.map(({tableName, description, columnConfigs}) => {
             let configuration = dict{
               "custom_name": tableName->(Utils.magic: string => JSON.t),
             }
@@ -132,15 +198,26 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableConfigs: array<track
             | Some(d) => configuration->Dict.set("comment", d->(Utils.magic: string => JSON.t))
             | None => ()
             }
-            let columnConfigEntries = columnDescriptions->Dict.toArray
+            let columnConfigEntries = columnConfigs->Dict.toArray
             if columnConfigEntries->Array.length > 0 {
-              let columnConfig = dict{}
-              columnConfigEntries->Array.forEach(((column, comment)) =>
-                columnConfig->Dict.set(column, {"comment": comment}->(Utils.magic: {..} => JSON.t))
-              )
+              let columnConfigJson = dict{}
+              columnConfigEntries->Array.forEach(((column, config)) => {
+                let entry = dict{}
+                switch config.customName {
+                | Some(customName) =>
+                  entry->Dict.set("custom_name", customName->(Utils.magic: string => JSON.t))
+                | None => ()
+                }
+                switch config.comment {
+                | Some(comment) =>
+                  entry->Dict.set("comment", comment->(Utils.magic: string => JSON.t))
+                | None => ()
+                }
+                columnConfigJson->Dict.set(column, entry->(Utils.magic: dict<JSON.t> => JSON.t))
+              })
               configuration->Dict.set(
                 "column_config",
-                columnConfig->(Utils.magic: dict<JSON.t> => JSON.t),
+                columnConfigJson->(Utils.magic: dict<JSON.t> => JSON.t),
               )
             }
             {
@@ -216,7 +293,8 @@ let createEntityRelationship = async (
   ~isDerivedFrom: bool,
   ~comment: option<string>=?,
 ) => {
-  let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}_id" : "id"`
+  // The column_mapping references columns by their db names
+  let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}" : "id"`
 
   let tableJson = {
     "schema": pgSchema,
@@ -266,44 +344,36 @@ let trackDatabase = async (
     {
       tableName: InternalTable.RawEvents.table.tableName,
       description: None,
-      columnDescriptions: dict{},
+      columnConfigs: dict{},
     },
     {
       tableName: InternalTable.Views.metaViewName,
       description: None,
-      columnDescriptions: dict{},
+      columnConfigs: dict{},
     },
     {
       tableName: InternalTable.Views.chainMetadataViewName,
       description: None,
-      columnDescriptions: dict{},
+      columnConfigs: dict{},
     },
   ]
   let userTableConfigs = userEntities->Array.map(entity => {
-    let columnDescriptions = dict{}
-    entity.table.fields->Array.forEach(fieldOrDerived =>
-      switch fieldOrDerived {
-      | Table.Field(field) =>
-        switch field.description {
-        | Some(d) => columnDescriptions->Dict.set(field->Table.getDbFieldName, d)
-        | None => ()
-        }
-      | Table.DerivedFrom(_) => ()
-      }
-    )
-    {
-      tableName: entity.table.tableName,
-      description: entity.table.description,
-      columnDescriptions,
-    }
+    tableName: entity.table.tableName,
+    description: entity.table.description,
+    columnConfigs: entity.table->makeColumnConfigs,
   })
-  let tableConfigs = [exposedInternalTableConfigs, userTableConfigs]->Belt.Array.concatMany
+  let tableConfigs = [exposedInternalTableConfigs, userTableConfigs]->Array.flat
   let tableNames = tableConfigs->Array.map(c => c.tableName)
 
   Logging.info("Tracking tables in Hasura")
 
   let _ = await clearHasuraMetadata(~endpoint, ~auth)
 
+  // Force Hasura to re-introspect the source schema before tracking, otherwise
+  // freshly-created user tables may be invisible to pg_track_tables and the call
+  // returns `metadata-warnings` (HTTP 400), leaving tracking permanently broken.
+  await reloadHasuraMetadata(~endpoint, ~auth)
+
   await trackTables(~endpoint, ~auth, ~pgSchema, ~tableConfigs)
 
   for i in 0 to tableNames->Array.length - 1 {
@@ -328,7 +398,7 @@ let trackDatabase = async (
       let derivedFromField = derivedFromFields->Array.getUnsafe(j)
       //determines the actual name of the underlying relational field (if it's an entity mapping then suffixes _id for eg.)
       let relationalFieldName =
-        schema->Schema.getDerivedFromFieldName(derivedFromField)->Utils.unwrapResultExn
+        schema->Schema.getDerivedFromPgFieldName(derivedFromField)->Utils.unwrapResultExn
 
       await createEntityRelationship(
         ~endpoint,
@@ -356,7 +426,7 @@ let trackDatabase = async (
         ~relationshipType="object",
         ~isDerivedFrom=false,
         ~objectName=field.fieldName,
-        ~relationalKey=field.fieldName,
+        ~relationalKey=field->Table.getPgDbFieldName,
         ~mappedEntity=linkedEntityName,
         ~comment=?field.description,
       )