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

package/src/Hasura.res

@@ -46,19 +46,6 @@ let trackTablesRoute = Rest.route(() => {
   responses,
 })
 
-let createSelectPermissionRoute = Rest.route(() => {
-  method: Post,
-  path: "",
-  input: s => {
-    let _ = s.field("type", S.literal("pg_create_select_permission"))
-    {
-      "args": s.field("args", S.json(~validate=false)),
-      "auth": s->auth,
-    }
-  },
-  responses,
-})
-
 let rawBodyRoute = Rest.route(() => {
   method: Post,
   path: "",
@@ -71,36 +58,33 @@ let rawBodyRoute = Rest.route(() => {
   responses,
 })
 
-let bulkKeepGoingRoute = Rest.route(() => {
-  method: Post,
-  path: "",
-  input: s => {
-    let _ = s.field("type", S.literal("bulk_keep_going"))
-    {
-      "args": s.field("args", S.json(~validate=false)),
-      "auth": s->auth,
+let sendOperation = async (~endpoint, ~auth, ~operation: Js.Json.t) => {
+  let maxRetries = 3
+  let rec retry = async (~attempt) => {
+    try {
+      let _ = await rawBodyRoute->Rest.fetch(
+        {
+          "bodyString": operation->Js.Json.stringify,
+          "auth": auth,
+        },
+        ~client=Rest.client(endpoint),
+      )
+    } catch {
+    | exn =>
+      if attempt < maxRetries {
+        let backoffMs = Js.Math.pow_float(~base=2.0, ~exp=attempt->Belt.Int.toFloat)->Belt.Float.toInt * 1000
+        await Time.resolvePromiseAfterDelay(~delayMilliseconds=backoffMs)
+        await retry(~attempt=attempt + 1)
+      } else {
+        Logging.warn({
+          "msg": "Hasura configuration request failed. Indexing will still work - but you may have issues querying data via GraphQL.",
+          "err": exn->Utils.prettifyExn,
+        })
+      }
     }
-  },
-  responses: [
-    (s: Rest.Response.s) => {
-      s.status(200)
-      s.data(S.json(~validate=false))
-    },
-  ],
-})
-let bulkKeepGoingErrorsSchema = S.array(
-  S.union([
-    S.object(s => {
-      s.tag("message", "success")
-      None
-    }),
-    S.object(s => {
-      Some(s.field("error", S.string))
-    }),
-  ]),
-)->S.transform(_ => {
-  parser: a => Belt.Array.keepMapU(a, a => a),
-})
+  }
+  await retry(~attempt=0)
+}
 
 let clearHasuraMetadata = async (~endpoint, ~auth) => {
   try {
@@ -113,7 +97,7 @@ let clearHasuraMetadata = async (~endpoint, ~auth) => {
   } catch {
   | exn =>
     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": exn->Utils.prettifyExn,
     })
   }
@@ -154,44 +138,47 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>
   } catch {
   | exn =>
     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": exn->Utils.prettifyExn,
     })
   }
 }
 
-type bulkOperation = {
-  \"type": string,
-  args: Js.Json.t,
-}
-
-let createSelectPermissionOperation = (
+let createSelectPermission = async (
+  ~endpoint,
+  ~auth,
   ~tableName: string,
   ~pgSchema,
   ~responseLimit,
   ~aggregateEntities,
-): bulkOperation => {
-  {
-    \"type": "pg_create_select_permission",
-    args: {
-      "table": {
-        "schema": pgSchema,
-        "name": tableName,
-      },
-      "role": "public",
-      "source": "default",
-      "permission": {
-        "columns": "*",
-        "filter": Js.Obj.empty(),
-        "limit": responseLimit,
-        "allow_aggregations": aggregateEntities->Js.Array2.includes(tableName),
+) => {
+  await sendOperation(
+    ~endpoint,
+    ~auth,
+    ~operation={
+      "type": "pg_create_select_permission",
+      "args": {
+        "table": {
+          "schema": pgSchema,
+          "name": tableName,
+        },
+        "role": "public",
+        "source": "default",
+        "permission": {
+          "columns": "*",
+          "filter": Js.Obj.empty(),
+          "limit": responseLimit,
+          "allow_aggregations": aggregateEntities->Js.Array2.includes(tableName),
+        },
       },
     }->(Utils.magic: 'a => Js.Json.t),
-  }
+  )
 }
 
-let createEntityRelationshipOperation = (
+let createEntityRelationship = async (
+  ~endpoint,
+  ~auth,
   ~pgSchema,
   ~tableName: string,
   ~relationshipType: string,
@@ -199,73 +186,33 @@ let createEntityRelationshipOperation = (
   ~objectName: string,
   ~mappedEntity: string,
   ~isDerivedFrom: bool,
-): bulkOperation => {
+) => {
   let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}_id" : "id"`
 
-  {
-    \"type": `pg_create_${relationshipType}_relationship`,
-    args: {
-      "table": {
-        "schema": pgSchema,
-        "name": tableName,
-      },
-      "name": objectName,
-      "source": "default",
-      "using": {
-        "manual_configuration": {
-          "remote_table": {
-            "schema": pgSchema,
-            "name": mappedEntity,
+  await sendOperation(
+    ~endpoint,
+    ~auth,
+    ~operation={
+      "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": Js.Json.parseExn(`{${derivedFromTo}}`),
           },
-          "column_mapping": Js.Json.parseExn(`{${derivedFromTo}}`),
         },
       },
     }->(Utils.magic: 'a => Js.Json.t),
-  }
-}
-
-let executeBulkKeepGoing = async (~endpoint, ~auth, ~operations: array<bulkOperation>) => {
-  if operations->Js.Array2.length === 0 {
-    Logging.trace("No hasura bulk configuration operations to execute")
-  } else {
-    try {
-      let result = await bulkKeepGoingRoute->Rest.fetch(
-        {
-          "auth": auth,
-          "args": operations->(Utils.magic: 'a => Js.Json.t),
-        },
-        ~client=Rest.client(endpoint),
-      )
-
-      let errors = try {
-        result->S.parseJsonOrThrow(bulkKeepGoingErrorsSchema)
-      } catch {
-      | S.Raised(error) => [error->S.Error.message]
-      | exn => [exn->Utils.prettifyExn->Utils.magic]
-      }
-
-      switch errors {
-      | [] =>
-        Logging.trace({
-          "msg": "Hasura configuration completed",
-          "operations": operations->Js.Array2.length,
-        })
-      | _ =>
-        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->Js.Array2.length,
-        })
-      }
-    } catch {
-    | exn =>
-      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->Js.Array2.length,
-        "err": exn->Utils.prettifyExn,
-      })
-    }
-  }
+  )
 }
 
 let trackDatabase = async (
@@ -291,64 +238,53 @@ let trackDatabase = async (
 
   await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
 
-  // Collect all operations for bulk execution
-  let allOperations = []
-
-  // Add select permission operations
-  tableNames->Js.Array2.forEach(tableName => {
-    allOperations
-    ->Js.Array2.push(
-      createSelectPermissionOperation(~tableName, ~pgSchema, ~responseLimit, ~aggregateEntities),
-    )
-    ->ignore
-  })
+  for i in 0 to tableNames->Js.Array2.length - 1 {
+    let tableName = tableNames->Js.Array2.unsafe_get(i)
+    await createSelectPermission(~endpoint, ~auth, ~tableName, ~pgSchema, ~responseLimit, ~aggregateEntities)
+  }
 
-  // Add relationship operations
-  userEntities->Js.Array2.forEach(entityConfig => {
+  for i in 0 to userEntities->Js.Array2.length - 1 {
+    let entityConfig = userEntities->Js.Array2.unsafe_get(i)
     let {tableName} = entityConfig.table
 
     //Set array relationships
-    entityConfig.table
-    ->Table.getDerivedFromFields
-    ->Js.Array2.forEach(derivedFromField => {
+    let derivedFromFields = entityConfig.table->Table.getDerivedFromFields
+    for j in 0 to derivedFromFields->Js.Array2.length - 1 {
+      let derivedFromField = derivedFromFields->Js.Array2.unsafe_get(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
 
-      allOperations
-      ->Js.Array2.push(
-        createEntityRelationshipOperation(
-          ~pgSchema,
-          ~tableName,
-          ~relationshipType="array",
-          ~isDerivedFrom=true,
-          ~objectName=derivedFromField.fieldName,
-          ~relationalKey=relationalFieldName,
-          ~mappedEntity=derivedFromField.derivedFromEntity,
-        ),
+      await createEntityRelationship(
+        ~endpoint,
+        ~auth,
+        ~pgSchema,
+        ~tableName,
+        ~relationshipType="array",
+        ~isDerivedFrom=true,
+        ~objectName=derivedFromField.fieldName,
+        ~relationalKey=relationalFieldName,
+        ~mappedEntity=derivedFromField.derivedFromEntity,
       )
-      ->ignore
-    })
+    }
 
     //Set object relationships
-    entityConfig.table
-    ->Table.getLinkedEntityFields
-    ->Js.Array2.forEach(((field, linkedEntityName)) => {
-      allOperations
-      ->Js.Array2.push(
-        createEntityRelationshipOperation(
-          ~pgSchema,
-          ~tableName,
-          ~relationshipType="object",
-          ~isDerivedFrom=false,
-          ~objectName=field.fieldName,
-          ~relationalKey=field.fieldName,
-          ~mappedEntity=linkedEntityName,
-        ),
+    let linkedEntityFields = entityConfig.table->Table.getLinkedEntityFields
+    for j in 0 to linkedEntityFields->Js.Array2.length - 1 {
+      let (field, linkedEntityName) = linkedEntityFields->Js.Array2.unsafe_get(j)
+      await createEntityRelationship(
+        ~endpoint,
+        ~auth,
+        ~pgSchema,
+        ~tableName,
+        ~relationshipType="object",
+        ~isDerivedFrom=false,
+        ~objectName=field.fieldName,
+        ~relationalKey=field.fieldName,
+        ~mappedEntity=linkedEntityName,
       )
-      ->ignore
-    })
-  })
+    }
+  }
 
-  await executeBulkKeepGoing(~endpoint, ~auth, ~operations=allOperations)
+  Logging.info("Hasura configuration completed")
 }

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)