envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/Hasura.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Rest from "./vendored/Rest.res.mjs";
+import * as Time from "./Time.res.mjs";
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
@@ -60,21 +61,6 @@ function trackTablesRoute() {
         };
 }
 
-function createSelectPermissionRoute() {
-  return {
-          method: "POST",
-          path: "",
-          input: (function (s) {
-              s.field("type", S$RescriptSchema.literal("pg_create_select_permission"));
-              return {
-                      args: s.field("args", S$RescriptSchema.json(false)),
-                      auth: auth(s)
-                    };
-            }),
-          responses: responses
-        };
-}
-
 function rawBodyRoute() {
   return {
           method: "POST",
@@ -89,41 +75,31 @@ function rawBodyRoute() {
         };
 }
 
-function bulkKeepGoingRoute() {
-  return {
-          method: "POST",
-          path: "",
-          input: (function (s) {
-              s.field("type", S$RescriptSchema.literal("bulk_keep_going"));
-              return {
-                      args: s.field("args", S$RescriptSchema.json(false)),
-                      auth: auth(s)
-                    };
-            }),
-          responses: [(function (s) {
-                s.status(200);
-                return s.data(S$RescriptSchema.json(false));
-              })]
-        };
+async function sendOperation(endpoint, auth, operation) {
+  var retry = async function (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);
+      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)
+                  });
+      }
+      var backoffMs = Math.imul(Math.pow(2.0, attempt) | 0, 1000);
+      await Time.resolvePromiseAfterDelay(backoffMs);
+      return await retry(attempt + 1 | 0);
+    }
+  };
+  return await retry(0);
 }
 
-var bulkKeepGoingErrorsSchema = S$RescriptSchema.transform(S$RescriptSchema.array(S$RescriptSchema.union([
-              S$RescriptSchema.object(function (s) {
-                    s.tag("message", "success");
-                  }),
-              S$RescriptSchema.object(function (s) {
-                    return s.f("error", S$RescriptSchema.string);
-                  })
-            ])), (function (param) {
-        return {
-                p: (function (a) {
-                    return Belt_Array.keepMapU(a, (function (a) {
-                                  return a;
-                                }));
-                  })
-              };
-      }));
-
 async function clearHasuraMetadata(endpoint, auth) {
   try {
     var result = await Rest.$$fetch(clearMetadataRoute, auth, Rest.client(endpoint, undefined));
@@ -134,7 +110,7 @@ async function clearHasuraMetadata(endpoint, auth) {
   catch (raw_exn){
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
     return Logging.error({
-                msg: "EE806: There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                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)
               });
   }
@@ -169,95 +145,55 @@ async function trackTables(endpoint, auth, pgSchema, tableNames) {
   catch (raw_exn){
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
     return Logging.error({
-                msg: "EE807: There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                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)
               });
   }
 }
 
-function createSelectPermissionOperation(tableName, pgSchema, responseLimit, aggregateEntities) {
-  return {
-          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 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)
+                }
+              }
+            });
 }
 
-function createEntityRelationshipOperation(pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
+async function createEntityRelationship(endpoint, auth, pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
   var derivedFromTo = isDerivedFrom ? "\"id\": \"" + relationalKey + "\"" : "\"" + relationalKey + "_id\" : \"id\"";
-  return {
-          type: "pg_create_" + relationshipType + "_relationship",
-          args: {
-            table: {
-              schema: pgSchema,
-              name: tableName
-            },
-            name: objectName,
-            source: "default",
-            using: {
-              manual_configuration: {
-                remote_table: {
+  return await sendOperation(endpoint, auth, {
+              type: "pg_create_" + relationshipType + "_relationship",
+              args: {
+                table: {
                   schema: pgSchema,
-                  name: mappedEntity
+                  name: tableName
                 },
-                column_mapping: JSON.parse("{" + derivedFromTo + "}")
+                name: objectName,
+                source: "default",
+                using: {
+                  manual_configuration: {
+                    remote_table: {
+                      schema: pgSchema,
+                      name: mappedEntity
+                    },
+                    column_mapping: JSON.parse("{" + derivedFromTo + "}")
+                  }
+                }
               }
-            }
-          }
-        };
-}
-
-async function executeBulkKeepGoing(endpoint, auth, operations) {
-  if (operations.length === 0) {
-    return Logging.trace("No hasura bulk configuration operations to execute");
-  }
-  try {
-    var result = await Rest.$$fetch(bulkKeepGoingRoute, {
-          auth: auth,
-          args: operations
-        }, Rest.client(endpoint, undefined));
-    var errors;
-    try {
-      errors = S$RescriptSchema.parseJsonOrThrow(result, bulkKeepGoingErrorsSchema);
-    }
-    catch (raw_error){
-      var error = Caml_js_exceptions.internalToOCamlException(raw_error);
-      errors = error.RE_EXN_ID === S$RescriptSchema.Raised ? [S$RescriptSchema.$$Error.message(error._1)] : [Utils.prettifyExn(error)];
-    }
-    if (errors.length !== 0) {
-      return Logging.warn({
-                  msg: "Hasura configuration completed with errors. Indexing will still work - but you may have issues querying data via GraphQL.",
-                  errors: errors,
-                  operations: operations.length
-                });
-    } else {
-      return Logging.trace({
-                  msg: "Hasura configuration completed",
-                  operations: operations.length
-                });
-    }
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    return Logging.error({
-                msg: "EE809: There was an issue executing bulk operations in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                operations: operations.length,
-                err: Utils.prettifyExn(exn)
-              });
-  }
+            });
 }
 
 async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
@@ -276,23 +212,28 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
   await trackTables(endpoint, auth, pgSchema, tableNames);
-  var allOperations = [];
-  tableNames.forEach(function (tableName) {
-        allOperations.push(createSelectPermissionOperation(tableName, pgSchema, responseLimit, aggregateEntities));
-      });
-  userEntities.forEach(function (entityConfig) {
-        var match = entityConfig.table;
-        var tableName = match.tableName;
-        Table.getDerivedFromFields(entityConfig.table).forEach(function (derivedFromField) {
-              var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
-              allOperations.push(createEntityRelationshipOperation(pgSchema, tableName, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true));
-            });
-        Table.getLinkedEntityFields(entityConfig.table).forEach(function (param) {
-              var field = param[0];
-              allOperations.push(createEntityRelationshipOperation(pgSchema, tableName, "object", field.fieldName, field.fieldName, param[1], false));
-            });
-      });
-  return await executeBulkKeepGoing(endpoint, auth, allOperations);
+  for(var i = 0 ,i_finish = tableNames.length; i < i_finish; ++i){
+    var 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));
+      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];
+      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", field.fieldName, field.fieldName, match$1[1], false);
+    }
+  }
+  return Logging.info("Hasura configuration completed");
 }
 
 export {
@@ -300,15 +241,12 @@ export {
   responses ,
   clearMetadataRoute ,
   trackTablesRoute ,
-  createSelectPermissionRoute ,
   rawBodyRoute ,
-  bulkKeepGoingRoute ,
-  bulkKeepGoingErrorsSchema ,
+  sendOperation ,
   clearHasuraMetadata ,
   trackTables ,
-  createSelectPermissionOperation ,
-  createEntityRelationshipOperation ,
-  executeBulkKeepGoing ,
+  createSelectPermission ,
+  createEntityRelationship ,
   trackDatabase ,
 }
-/* bulkKeepGoingErrorsSchema Not a pure module */
+/* Rest Not a pure module */

package/src/InMemoryStore.res

@@ -100,7 +100,7 @@ let isRollingBack = (inMemoryStore: t) => inMemoryStore.rollbackTargetCheckpoint
 
 let setBatchDcs = (inMemoryStore: t, ~batch: Batch.t, ~shouldSaveHistory) => {
   let inMemTable =
-    inMemoryStore->getInMemTable(~entityConfig=InternalTable.DynamicContractRegistry.config)
+    inMemoryStore->getInMemTable(~entityConfig=InternalTable.DynamicContractRegistry.entityConfig)
 
   let itemIdx = ref(0)
 

package/src/InMemoryStore.res.mjs

@@ -2,12 +2,12 @@
 
 import * as $$Array from "rescript/lib/es6/array.js";
 import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as EventUtils from "./EventUtils.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 
 function hashRawEventsKey(key) {
@@ -102,7 +102,7 @@ function isRollingBack(inMemoryStore) {
 }
 
 function setBatchDcs(inMemoryStore, batch, shouldSaveHistory) {
-  var inMemTable = getInMemTable(inMemoryStore, InternalTable.DynamicContractRegistry.config);
+  var inMemTable = getInMemTable(inMemoryStore, Config.DynamicContractRegistry.entityConfig);
   var itemIdx = 0;
   for(var checkpoint = 0 ,checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint){
     var checkpointId = batch.checkpointIds[checkpoint];
@@ -114,7 +114,7 @@ function setBatchDcs(inMemoryStore, batch, shouldSaveHistory) {
       if (dcs !== undefined) {
         for(var dcIdx = 0 ,dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx){
           var dc = dcs[dcIdx];
-          var entity_id = InternalTable.DynamicContractRegistry.makeId(chainId, dc.address);
+          var entity_id = Config.DynamicContractRegistry.makeId(chainId, dc.address);
           var entity_registering_event_block_number = item.blockNumber;
           var entity_registering_event_log_index = item.logIndex;
           var entity_registering_event_block_timestamp = item.timestamp;

package/src/InMemoryTable.res

@@ -51,7 +51,7 @@ module Entity = {
   // Helper to extract entity ID from any entity
   exception UnexpectedIdNotDefinedOnEntity
   let getEntityIdUnsafe = (entity: 'entity): string =>
-    switch Utils.magic(entity)["id"] {
+    switch (entity->(Utils.magic: 'entity => {"id": option<string>}))["id"] {
     | Some(id) => id
     | None =>
       UnexpectedIdNotDefinedOnEntity->ErrorHandling.mkLogAndRaise(

package/src/InMemoryTable.res.mjs

@@ -54,7 +54,7 @@ var UnexpectedIdNotDefinedOnEntity = /* @__PURE__ */Caml_exceptions.create("InMe
 function getEntityIdUnsafe(entity) {
   var id = entity.id;
   if (id !== undefined) {
-    return Caml_option.valFromOption(id);
+    return id;
   } else {
     return ErrorHandling.mkLogAndRaise(undefined, "Property 'id' does not exist on expected entity object", {
                 RE_EXN_ID: UnexpectedIdNotDefinedOnEntity

package/src/Internal.gen.ts

@@ -10,6 +10,8 @@ import type {Invalid as $$noEventFilters} from './Types.ts';
 import type {t as Address_t} from './Address.gen.js';
 
 export type genericEvent<params,block,transaction> = {
+  readonly contractName: string; 
+  readonly eventName: string; 
   readonly params: params; 
   readonly chainId: number; 
   readonly srcAddress: Address_t; 
@@ -45,6 +47,10 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly eventFilters?: eventFilters
 };
 
+export abstract class fuelEventConfig { protected opaque!: any }; /* simulate opaque types */
+
+export abstract class evmEventConfig { protected opaque!: any }; /* simulate opaque types */
+
 export type eventOptions<eventFilters> = { readonly wildcard?: boolean; readonly eventFilters?: eventFilters };
 
 export type fuelSupplyParams = { readonly subId: string; readonly amount: bigint };