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

package/src/Hasura.res.mjs

@@ -6,93 +6,90 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function auth(s) {
   return {
-          role: s.header("X-Hasura-Role", S$RescriptSchema.string),
-          secret: s.header("X-Hasura-Admin-Secret", S$RescriptSchema.string)
-        };
+    role: s.header("X-Hasura-Role", S$RescriptSchema.string),
+    secret: s.header("X-Hasura-Admin-Secret", S$RescriptSchema.string)
+  };
 }
 
-var responses = [
-  (function (s) {
-      s.status(200);
-      s.data(S$RescriptSchema.unknown);
-      return "QuerySucceeded";
-    }),
-  (function (s) {
-      s.field("code", S$RescriptSchema.$$enum([
-                "already-exists",
-                "already-tracked"
-              ]));
-      return "AlreadyDone";
-    })
+let responses = [
+  s => {
+    s.status(200);
+    s.data(S$RescriptSchema.unknown);
+    return "QuerySucceeded";
+  },
+  s => {
+    s.field("code", S$RescriptSchema.$$enum([
+      "already-exists",
+      "already-tracked"
+    ]));
+    return "AlreadyDone";
+  }
 ];
 
 function clearMetadataRoute() {
   return {
-          method: "POST",
-          path: "",
-          input: (function (s) {
-              s.field("type", S$RescriptSchema.literal("clear_metadata"));
-              s.field("args", S$RescriptSchema.literal({}));
-              return auth(s);
-            }),
-          responses: responses
-        };
+    method: "POST",
+    path: "",
+    input: s => {
+      s.field("type", S$RescriptSchema.literal("clear_metadata"));
+      s.field("args", S$RescriptSchema.literal({}));
+      return auth(s);
+    },
+    responses: responses
+  };
 }
 
 function trackTablesRoute() {
   return {
-          method: "POST",
-          path: "",
-          input: (function (s) {
-              s.field("type", S$RescriptSchema.literal("pg_track_tables"));
-              return {
-                      args: s.field("args", S$RescriptSchema.json(false)),
-                      auth: auth(s)
-                    };
-            }),
-          responses: responses
-        };
+    method: "POST",
+    path: "",
+    input: s => {
+      s.field("type", S$RescriptSchema.literal("pg_track_tables"));
+      return {
+        args: s.field("args", S$RescriptSchema.json(false)),
+        auth: auth(s)
+      };
+    },
+    responses: responses
+  };
 }
 
 function rawBodyRoute() {
   return {
-          method: "POST",
-          path: "",
-          input: (function (s) {
-              return {
-                      bodyString: s.rawBody(S$RescriptSchema.string),
-                      auth: auth(s)
-                    };
-            }),
-          responses: responses
-        };
+    method: "POST",
+    path: "",
+    input: s => ({
+      bodyString: s.rawBody(S$RescriptSchema.string),
+      auth: auth(s)
+    }),
+    responses: responses
+  };
 }
 
 async function sendOperation(endpoint, auth, operation) {
-  var retry = async function (attempt) {
+  let retry = async attempt => {
     try {
-      await Rest.$$fetch(rawBodyRoute, {
-            bodyString: JSON.stringify(operation),
-            auth: auth
-          }, Rest.client(endpoint, undefined));
-      return ;
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      await Rest.fetch(rawBodyRoute, {
+        bodyString: JSON.stringify(operation),
+        auth: auth
+      }, Rest.client(endpoint, undefined));
+      return;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       if (attempt >= 3) {
         return Logging.warn({
-                    msg: "Hasura configuration request failed. Indexing will still work - but you may have issues querying data via GraphQL.",
-                    err: Utils.prettifyExn(exn)
-                  });
+          msg: "Hasura configuration request failed. Indexing will still work - but you may have issues querying data via GraphQL.",
+          err: Utils.prettifyExn(exn)
+        });
       }
-      var backoffMs = Math.imul(Math.pow(2.0, attempt) | 0, 1000);
+      let backoffMs = (Math.pow(2.0, attempt) | 0) * 1000 | 0;
       await Time.resolvePromiseAfterDelay(backoffMs);
       return await retry(attempt + 1 | 0);
     }
@@ -102,134 +99,128 @@ async function sendOperation(endpoint, auth, operation) {
 
 async function clearHasuraMetadata(endpoint, auth) {
   try {
-    var result = await Rest.$$fetch(clearMetadataRoute, auth, Rest.client(endpoint, undefined));
-    var msg;
-    msg = result === "QuerySucceeded" ? "Hasura metadata cleared" : "Hasura metadata already cleared";
-    return Logging.trace(msg);
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    let result = await Rest.fetch(clearMetadataRoute, auth, Rest.client(endpoint, undefined));
+    let tmp;
+    tmp = result === "QuerySucceeded" ? "Hasura metadata cleared" : "Hasura metadata already cleared";
+    return Logging.trace(tmp);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     return Logging.error({
-                msg: "There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                err: Utils.prettifyExn(exn)
-              });
+      msg: `There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
+      err: Utils.prettifyExn(exn)
+    });
   }
 }
 
 async function trackTables(endpoint, auth, pgSchema, tableNames) {
   try {
-    var result = await Rest.$$fetch(trackTablesRoute, {
-          auth: auth,
-          args: {
-            allow_warnings: false,
-            tables: tableNames.map(function (tableName) {
-                  return {
-                          table: {
-                            name: tableName,
-                            schema: pgSchema
-                          },
-                          configuration: {
-                            custom_name: tableName
-                          }
-                        };
-                })
+    let result = await Rest.fetch(trackTablesRoute, {
+      auth: auth,
+      args: {
+        allow_warnings: false,
+        tables: tableNames.map(tableName => ({
+          table: {
+            name: tableName,
+            schema: pgSchema
+          },
+          configuration: {
+            custom_name: tableName
           }
-        }, Rest.client(endpoint, undefined));
-    var msg;
+        }))
+      }
+    }, Rest.client(endpoint, undefined));
+    let msg;
     msg = result === "QuerySucceeded" ? "Hasura finished tracking tables" : "Hasura tables already tracked";
     return Logging.trace({
-                msg: msg,
-                tableNames: tableNames
-              });
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      msg: msg,
+      tableNames: tableNames
+    });
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     return Logging.error({
-                msg: "There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                tableNames: tableNames,
-                err: Utils.prettifyExn(exn)
-              });
+      msg: `There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
+      tableNames: tableNames,
+      err: Utils.prettifyExn(exn)
+    });
   }
 }
 
 async function createSelectPermission(endpoint, auth, tableName, pgSchema, responseLimit, aggregateEntities) {
   return await sendOperation(endpoint, auth, {
-              type: "pg_create_select_permission",
-              args: {
-                table: {
-                  schema: pgSchema,
-                  name: tableName
-                },
-                role: "public",
-                source: "default",
-                permission: {
-                  columns: "*",
-                  filter: {},
-                  limit: responseLimit,
-                  allow_aggregations: aggregateEntities.includes(tableName)
-                }
-              }
-            });
+    type: "pg_create_select_permission",
+    args: {
+      table: {
+        schema: pgSchema,
+        name: tableName
+      },
+      role: "public",
+      source: "default",
+      permission: {
+        columns: "*",
+        filter: {},
+        limit: responseLimit,
+        allow_aggregations: aggregateEntities.includes(tableName)
+      }
+    }
+  });
 }
 
 async function createEntityRelationship(endpoint, auth, pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
-  var derivedFromTo = isDerivedFrom ? "\"id\": \"" + relationalKey + "\"" : "\"" + relationalKey + "_id\" : \"id\"";
+  let derivedFromTo = isDerivedFrom ? `"id": "` + relationalKey + `"` : `"` + relationalKey + `_id" : "id"`;
   return await sendOperation(endpoint, auth, {
-              type: "pg_create_" + relationshipType + "_relationship",
-              args: {
-                table: {
-                  schema: pgSchema,
-                  name: tableName
-                },
-                name: objectName,
-                source: "default",
-                using: {
-                  manual_configuration: {
-                    remote_table: {
-                      schema: pgSchema,
-                      name: mappedEntity
-                    },
-                    column_mapping: JSON.parse("{" + derivedFromTo + "}")
-                  }
-                }
-              }
-            });
+    type: `pg_create_` + relationshipType + `_relationship`,
+    args: {
+      table: {
+        schema: pgSchema,
+        name: tableName
+      },
+      name: objectName,
+      source: "default",
+      using: {
+        manual_configuration: {
+          remote_table: {
+            schema: pgSchema,
+            name: mappedEntity
+          },
+          column_mapping: JSON.parse(`{` + derivedFromTo + `}`)
+        }
+      }
+    }
+  });
 }
 
 async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
-  var exposedInternalTableNames = [
+  let exposedInternalTableNames = [
     InternalTable.RawEvents.table.tableName,
     InternalTable.Views.metaViewName,
     InternalTable.Views.chainMetadataViewName
   ];
-  var userTableNames = userEntities.map(function (entity) {
-        return entity.table.tableName;
-      });
-  var tableNames = Belt_Array.concatMany([
-        exposedInternalTableNames,
-        userTableNames
-      ]);
+  let userTableNames = userEntities.map(entity => entity.table.tableName);
+  let tableNames = Belt_Array.concatMany([
+    exposedInternalTableNames,
+    userTableNames
+  ]);
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
   await trackTables(endpoint, auth, pgSchema, tableNames);
-  for(var i = 0 ,i_finish = tableNames.length; i < i_finish; ++i){
-    var tableName = tableNames[i];
+  for (let i = 0, i_finish = tableNames.length; i < i_finish; ++i) {
+    let tableName = tableNames[i];
     await createSelectPermission(endpoint, auth, tableName, pgSchema, responseLimit, aggregateEntities);
   }
-  for(var i$1 = 0 ,i_finish$1 = userEntities.length; i$1 < i_finish$1; ++i$1){
-    var entityConfig = userEntities[i$1];
-    var match = entityConfig.table;
-    var tableName$1 = match.tableName;
-    var derivedFromFields = Table.getDerivedFromFields(entityConfig.table);
-    for(var j = 0 ,j_finish = derivedFromFields.length; j < j_finish; ++j){
-      var derivedFromField = derivedFromFields[j];
-      var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
+  for (let i$1 = 0, i_finish$1 = userEntities.length; i$1 < i_finish$1; ++i$1) {
+    let entityConfig = userEntities[i$1];
+    let match = entityConfig.table;
+    let tableName$1 = match.tableName;
+    let derivedFromFields = Table.getDerivedFromFields(entityConfig.table);
+    for (let j = 0, j_finish = derivedFromFields.length; j < j_finish; ++j) {
+      let derivedFromField = derivedFromFields[j];
+      let relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
       await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true);
     }
-    var linkedEntityFields = Table.getLinkedEntityFields(entityConfig.table);
-    for(var j$1 = 0 ,j_finish$1 = linkedEntityFields.length; j$1 < j_finish$1; ++j$1){
-      var match$1 = linkedEntityFields[j$1];
-      var field = match$1[0];
+    let linkedEntityFields = Table.getLinkedEntityFields(entityConfig.table);
+    for (let j$1 = 0, j_finish$1 = linkedEntityFields.length; j$1 < j_finish$1; ++j$1) {
+      let match$1 = linkedEntityFields[j$1];
+      let field = match$1[0];
       await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", field.fieldName, field.fieldName, match$1[1], false);
     }
   }
@@ -237,16 +228,16 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
 }
 
 export {
-  auth ,
-  responses ,
-  clearMetadataRoute ,
-  trackTablesRoute ,
-  rawBodyRoute ,
-  sendOperation ,
-  clearHasuraMetadata ,
-  trackTables ,
-  createSelectPermission ,
-  createEntityRelationship ,
-  trackDatabase ,
+  auth,
+  responses,
+  clearMetadataRoute,
+  trackTablesRoute,
+  rawBodyRoute,
+  sendOperation,
+  clearHasuraMetadata,
+  trackTables,
+  createSelectPermission,
+  createEntityRelationship,
+  trackDatabase,
 }
 /* Rest Not a pure module */

package/src/InMemoryStore.res

@@ -1,4 +1,3 @@
-@genType
 type rawEventsKey = {
   chainId: int,
   eventId: string,
@@ -11,9 +10,9 @@ module EntityTables = {
   type t = dict<InMemoryTable.Entity.t<Internal.entity>>
   exception UndefinedEntity({entityName: string})
   let make = (entities: array<Internal.entityConfig>): t => {
-    let init = Js.Dict.empty()
+    let init = Dict.make()
     entities->Belt.Array.forEach(entityConfig => {
-      init->Js.Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
+      init->Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
     })
     init
   }
@@ -34,9 +33,9 @@ module EntityTables = {
 
   let clone = (self: t) => {
     self
-    ->Js.Dict.entries
+    ->Dict.toArray
     ->Belt.Array.map(((k, v)) => (k, v->InMemoryTable.Entity.clone))
-    ->Js.Dict.fromArray
+    ->Dict.fromArray
   }
 }
 
@@ -57,19 +56,19 @@ type t = {
 let make = (~entities: array<Internal.entityConfig>, ~rollbackTargetCheckpointId=?): t => {
   rawEvents: InMemoryTable.make(~hash=hashRawEventsKey),
   entities: EntityTables.make(entities),
-  effects: Js.Dict.empty(),
+  effects: Dict.make(),
   rollbackTargetCheckpointId,
 }
 
 let clone = (self: t) => {
   rawEvents: self.rawEvents->InMemoryTable.clone,
   entities: self.entities->EntityTables.clone,
-  effects: Js.Dict.map(table => {
+  effects: Dict.mapValues(self.effects, table => {
     idsToStore: table.idsToStore->Array.copy,
     invalidationsCount: table.invalidationsCount,
     dict: table.dict->Utils.Dict.shallowCopy,
     effect: table.effect,
-  }, self.effects),
+  }),
   rollbackTargetCheckpointId: self.rollbackTargetCheckpointId,
 }
 
@@ -80,11 +79,11 @@ let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
   | None =>
     let table = {
       idsToStore: [],
-      dict: Js.Dict.empty(),
+      dict: Dict.make(),
       invalidationsCount: 0,
       effect,
     }
-    inMemoryStore.effects->Js.Dict.set(key, table)
+    inMemoryStore.effects->Dict.set(key, table)
     table
   }
 }
@@ -100,43 +99,37 @@ let isRollingBack = (inMemoryStore: t) => inMemoryStore.rollbackTargetCheckpoint
 
 let setBatchDcs = (inMemoryStore: t, ~batch: Batch.t, ~shouldSaveHistory) => {
   let inMemTable =
-    inMemoryStore->getInMemTable(~entityConfig=InternalTable.DynamicContractRegistry.entityConfig)
+    inMemoryStore->getInMemTable(~entityConfig=InternalTable.EnvioAddresses.entityConfig)
 
   let itemIdx = ref(0)
 
   for checkpoint in 0 to batch.checkpointIds->Array.length - 1 {
-    let checkpointId = batch.checkpointIds->Js.Array2.unsafe_get(checkpoint)
-    let chainId = batch.checkpointChainIds->Js.Array2.unsafe_get(checkpoint)
-    let checkpointEventsProcessed =
-      batch.checkpointEventsProcessed->Js.Array2.unsafe_get(checkpoint)
+    let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpoint)
+    let chainId = batch.checkpointChainIds->Array.getUnsafe(checkpoint)
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpoint)
 
     for idx in 0 to checkpointEventsProcessed - 1 {
-      let item = batch.items->Js.Array2.unsafe_get(itemIdx.contents + idx)
+      let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item->Internal.getItemDcs {
       | None => ()
       | Some(dcs) =>
         // Currently only events support contract registration, so we can cast to event item
         let eventItem = item->Internal.castUnsafeEventItem
         for dcIdx in 0 to dcs->Array.length - 1 {
-          let dc = dcs->Js.Array2.unsafe_get(dcIdx)
-          let entity: InternalTable.DynamicContractRegistry.t = {
-            id: InternalTable.DynamicContractRegistry.makeId(~chainId, ~contractAddress=dc.address),
+          let dc = dcs->Array.getUnsafe(dcIdx)
+          let entity: InternalTable.EnvioAddresses.t = {
+            id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
             chainId,
-            contractAddress: dc.address,
             contractName: dc.contractName,
-            registeringEventBlockNumber: eventItem.blockNumber,
-            registeringEventLogIndex: eventItem.logIndex,
-            registeringEventBlockTimestamp: eventItem.timestamp,
-            registeringEventContractName: eventItem.eventConfig.contractName,
-            registeringEventName: eventItem.eventConfig.name,
-            registeringEventSrcAddress: eventItem.event.srcAddress,
+            registrationBlock: eventItem.blockNumber,
+            registrationLogIndex: eventItem.logIndex,
           }
 
           inMemTable->InMemoryTable.Entity.set(
             Set({
               entityId: entity.id,
               checkpointId,
-              entity: entity->InternalTable.DynamicContractRegistry.castToInternal,
+              entity: entity->InternalTable.EnvioAddresses.castToInternal,
             }),
             ~shouldSaveHistory,
           )