envio 2.29.2 → 2.30.0

package/src/Hasura.res

@@ -71,12 +71,43 @@ 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,
+    }
+  },
+  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),
+})
+
 let clearHasuraMetadata = async (~endpoint, ~auth) => {
   try {
     let result = await clearMetadataRoute->Rest.fetch(auth, ~client=Rest.client(endpoint))
     let msg = switch result {
-    | QuerySucceeded => "Metadata Cleared"
-    | AlreadyDone => "Metadata Already Cleared"
+    | QuerySucceeded => "Hasura metadata cleared"
+    | AlreadyDone => "Hasura metadata already cleared"
     }
     Logging.trace(msg)
   } catch {
@@ -113,8 +144,8 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>
       ~client=Rest.client(endpoint),
     )
     let msg = switch result {
-    | QuerySucceeded => "Tables Tracked"
-    | AlreadyDone => "Table Already Tracked"
+    | QuerySucceeded => "Hasura finished tracking tables"
+    | AlreadyDone => "Hasura tables already tracked"
     }
     Logging.trace({
       "msg": msg,
@@ -130,91 +161,110 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>
   }
 }
 
-let createSelectPermissions = async (
-  ~auth,
-  ~endpoint,
+type bulkOperation = {
+  \"type": string,
+  args: Js.Json.t,
+}
+
+let createSelectPermissionOperation = (
   ~tableName: string,
   ~pgSchema,
   ~responseLimit,
   ~aggregateEntities,
-) => {
-  try {
-    let result = await createSelectPermissionRoute->Rest.fetch(
-      {
-        "auth": auth,
-        "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),
+): bulkOperation => {
+  {
+    \"type": "pg_create_select_permission",
+    args: {
+      "table": {
+        "schema": pgSchema,
+        "name": tableName,
       },
-      ~client=Rest.client(endpoint),
-    )
-    let msg = switch result {
-    | QuerySucceeded => "Hasura select permissions created"
-    | AlreadyDone => "Hasura select permissions already created"
-    }
-    Logging.trace({
-      "msg": msg,
-      "tableName": tableName,
-    })
-  } catch {
-  | exn =>
-    Logging.error({
-      "msg": `EE808: There was an issue setting up view permissions for the ${tableName} table in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
-      "tableName": tableName,
-      "err": exn->Utils.prettifyExn,
-    })
+      "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 createEntityRelationship = async (
+let createEntityRelationshipOperation = (
   ~pgSchema,
-  ~endpoint,
-  ~auth,
   ~tableName: string,
   ~relationshipType: string,
   ~relationalKey: string,
   ~objectName: string,
   ~mappedEntity: string,
   ~isDerivedFrom: bool,
-) => {
+): bulkOperation => {
   let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}_id" : "id"`
 
-  let bodyString = `{"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": {${derivedFromTo}}}}}}`
-
-  try {
-    let result = await rawBodyRoute->Rest.fetch(
-      {
-        "auth": auth,
-        "bodyString": bodyString,
+  {
+    \"type": `pg_create_${relationshipType}_relationship`,
+    args: {
+      "table": {
+        "schema": pgSchema,
+        "name": tableName,
       },
-      ~client=Rest.client(endpoint),
-    )
-    let msg = switch result {
-    | QuerySucceeded => `Hasura ${relationshipType} relationship created`
-    | AlreadyDone => `Hasura ${relationshipType} relationship already created`
+      "name": objectName,
+      "source": "default",
+      "using": {
+        "manual_configuration": {
+          "remote_table": {
+            "schema": pgSchema,
+            "name": mappedEntity,
+          },
+          "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,
+      })
     }
-    Logging.trace({
-      "msg": msg,
-      "tableName": tableName,
-    })
-  } catch {
-  | exn =>
-    Logging.error({
-      "msg": `EE808: There was an issue setting up ${relationshipType} relationship for the ${tableName} table in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
-      "tableName": tableName,
-      "err": exn->Utils.prettifyExn,
-    })
   }
 }
 
@@ -241,60 +291,64 @@ let trackDatabase = async (
 
   await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
 
-  let _ =
-    await tableNames
-    ->Js.Array2.map(tableName =>
-      createSelectPermissions(
-        ~endpoint,
-        ~auth,
-        ~tableName,
-        ~pgSchema,
-        ~responseLimit,
-        ~aggregateEntities,
-      )
-    )
-    ->Js.Array2.concatMany(
-      userEntities->Js.Array2.map(entityConfig => {
-        let {tableName} = entityConfig.table
-        [
-          //Set array relationships
-          entityConfig.table
-          ->Table.getDerivedFromFields
-          ->Js.Array2.map(derivedFromField => {
-            //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
+  // Collect all operations for bulk execution
+  let allOperations = []
 
-            createEntityRelationship(
-              ~endpoint,
-              ~auth,
-              ~pgSchema,
-              ~tableName,
-              ~relationshipType="array",
-              ~isDerivedFrom=true,
-              ~objectName=derivedFromField.fieldName,
-              ~relationalKey=relationalFieldName,
-              ~mappedEntity=derivedFromField.derivedFromEntity,
-            )
-          }),
-          //Set object relationships
-          entityConfig.table
-          ->Table.getLinkedEntityFields
-          ->Js.Array2.map(((field, linkedEntityName)) => {
-            createEntityRelationship(
-              ~endpoint,
-              ~auth,
-              ~pgSchema,
-              ~tableName,
-              ~relationshipType="object",
-              ~isDerivedFrom=false,
-              ~objectName=field.fieldName,
-              ~relationalKey=field.fieldName,
-              ~mappedEntity=linkedEntityName,
-            )
-          }),
-        ]->Utils.Array.flatten
-      }),
+  // Add select permission operations
+  tableNames->Js.Array2.forEach(tableName => {
+    allOperations
+    ->Js.Array2.push(
+      createSelectPermissionOperation(~tableName, ~pgSchema, ~responseLimit, ~aggregateEntities),
     )
-    ->Promise.all
+    ->ignore
+  })
+
+  // Add relationship operations
+  userEntities->Js.Array2.forEach(entityConfig => {
+    let {tableName} = entityConfig.table
+
+    //Set array relationships
+    entityConfig.table
+    ->Table.getDerivedFromFields
+    ->Js.Array2.forEach(derivedFromField => {
+      //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,
+        ),
+      )
+      ->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,
+        ),
+      )
+      ->ignore
+    })
+  })
+
+  await executeBulkKeepGoing(~endpoint, ~auth, ~operations=allOperations)
 }

package/src/Hasura.res.js

@@ -8,7 +8,6 @@ var Schema = require("./db/Schema.res.js");
 var Logging = require("./Logging.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var InternalTable = require("./db/InternalTable.res.js");
-var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
@@ -91,11 +90,46 @@ 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));
+              })]
+        };
+}
+
+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));
     var msg;
-    msg = result === "QuerySucceeded" ? "Metadata Cleared" : "Metadata Already Cleared";
+    msg = result === "QuerySucceeded" ? "Hasura metadata cleared" : "Hasura metadata already cleared";
     return Logging.trace(msg);
   }
   catch (raw_exn){
@@ -127,7 +161,7 @@ async function trackTables(endpoint, auth, pgSchema, tableNames) {
           }
         }, Rest.client(endpoint, undefined));
     var msg;
-    msg = result === "QuerySucceeded" ? "Tables Tracked" : "Table Already Tracked";
+    msg = result === "QuerySucceeded" ? "Hasura finished tracking tables" : "Hasura tables already tracked";
     return Logging.trace({
                 msg: msg,
                 tableNames: tableNames
@@ -143,10 +177,9 @@ async function trackTables(endpoint, auth, pgSchema, tableNames) {
   }
 }
 
-async function createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities) {
-  try {
-    var result = await Rest.$$fetch(createSelectPermissionRoute, {
-          auth: auth,
+function createSelectPermissionOperation(tableName, pgSchema, responseLimit, aggregateEntities) {
+  return {
+          type: "pg_create_select_permission",
           args: {
             table: {
               schema: pgSchema,
@@ -161,44 +194,68 @@ async function createSelectPermissions(auth, endpoint, tableName, pgSchema, resp
               allow_aggregations: aggregateEntities.includes(tableName)
             }
           }
-        }, Rest.client(endpoint, undefined));
-    var msg;
-    msg = result === "QuerySucceeded" ? "Hasura select permissions created" : "Hasura select permissions already created";
-    return Logging.trace({
-                msg: msg,
-                tableName: tableName
-              });
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    return Logging.error({
-                msg: "EE808: There was an issue setting up view permissions for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                tableName: tableName,
-                err: Utils.prettifyExn(exn)
-              });
-  }
+        };
 }
 
-async function createEntityRelationship(pgSchema, endpoint, auth, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
+function createEntityRelationshipOperation(pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom) {
   var derivedFromTo = isDerivedFrom ? "\"id\": \"" + relationalKey + "\"" : "\"" + relationalKey + "_id\" : \"id\"";
-  var bodyString = "{\"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\": {" + derivedFromTo + "}}}}}";
+  return {
+          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 executeBulkKeepGoing(endpoint, auth, operations) {
+  if (operations.length === 0) {
+    return Logging.trace("No hasura bulk configuration operations to execute");
+  }
   try {
-    var result = await Rest.$$fetch(rawBodyRoute, {
+    var result = await Rest.$$fetch(bulkKeepGoingRoute, {
           auth: auth,
-          bodyString: bodyString
+          args: operations
         }, Rest.client(endpoint, undefined));
-    var msg;
-    msg = result === "QuerySucceeded" ? "Hasura " + relationshipType + " relationship created" : "Hasura " + relationshipType + " relationship already created";
-    return Logging.trace({
-                msg: msg,
-                tableName: tableName
-              });
+    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: "EE808: There was an issue setting up " + relationshipType + " relationship for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                tableName: tableName,
+                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)
               });
   }
@@ -220,22 +277,23 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
   await trackTables(endpoint, auth, pgSchema, tableNames);
-  await Promise.all(Caml_splice_call.spliceObjApply(tableNames.map(function (tableName) {
-                return createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities);
-              }), "concat", [userEntities.map(function (entityConfig) {
-                  var match = entityConfig.table;
-                  var tableName = match.tableName;
-                  return [
-                            Table.getDerivedFromFields(entityConfig.table).map(function (derivedFromField) {
-                                  var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
-                                  return createEntityRelationship(pgSchema, endpoint, auth, tableName, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true);
-                                }),
-                            Table.getLinkedEntityFields(entityConfig.table).map(function (param) {
-                                  var field = param[0];
-                                  return createEntityRelationship(pgSchema, endpoint, auth, tableName, "object", field.fieldName, field.fieldName, param[1], false);
-                                })
-                          ].flat(1);
-                })]));
+  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);
 }
 
 exports.auth = auth;
@@ -244,9 +302,12 @@ exports.clearMetadataRoute = clearMetadataRoute;
 exports.trackTablesRoute = trackTablesRoute;
 exports.createSelectPermissionRoute = createSelectPermissionRoute;
 exports.rawBodyRoute = rawBodyRoute;
+exports.bulkKeepGoingRoute = bulkKeepGoingRoute;
+exports.bulkKeepGoingErrorsSchema = bulkKeepGoingErrorsSchema;
 exports.clearHasuraMetadata = clearHasuraMetadata;
 exports.trackTables = trackTables;
-exports.createSelectPermissions = createSelectPermissions;
-exports.createEntityRelationship = createEntityRelationship;
+exports.createSelectPermissionOperation = createSelectPermissionOperation;
+exports.createEntityRelationshipOperation = createEntityRelationshipOperation;
+exports.executeBulkKeepGoing = executeBulkKeepGoing;
 exports.trackDatabase = trackDatabase;
-/* Rest Not a pure module */
+/* bulkKeepGoingErrorsSchema Not a pure module */

package/src/Persistence.res

@@ -143,19 +143,7 @@ let init = {
           persistence.storageStatus = Ready(initialState)
           let checkpoints = Js.Dict.empty()
           initialState.chains->Js.Array2.forEach(c => {
-            let checkpoint = switch c.progressNextBlockLogIndex {
-            | Value(
-                logIndex,
-              ) => // Latest processed log index (not necessarily processed by the indexer)
-              {
-                "blockNumber": c.progressBlockNumber + 1,
-                "logIndex": logIndex,
-              }
-            | Null =>
-              // Or simply the latest processed block number (might be -1 if not set)
-              c.progressBlockNumber->Utils.magic
-            }
-            checkpoints->Utils.Dict.setByInt(c.id, checkpoint)
+            checkpoints->Utils.Dict.setByInt(c.id, c.progressBlockNumber)
           })
           Logging.info({
             "msg": `Successfully resumed indexing state! Continuing from the last checkpoint.`,

package/src/Persistence.res.js

@@ -84,13 +84,7 @@ async function init(persistence, chainConfigs, resetOpt) {
         };
         var checkpoints = {};
         initialState$1.chains.forEach(function (c) {
-              var logIndex = c._progress_log_index;
-              var checkpoint;
-              checkpoint = logIndex === null ? c.progress_block : ({
-                    blockNumber: c.progress_block + 1 | 0,
-                    logIndex: logIndex
-                  });
-              checkpoints[c.id] = checkpoint;
+              checkpoints[c.id] = c.progress_block;
             });
         Logging.info({
               msg: "Successfully resumed indexing state! Continuing from the last checkpoint.",

package/src/PgStorage.res

@@ -904,13 +904,6 @@ let make = (
       ->(Utils.magic: promise<array<unknown>> => promise<array<InternalTable.Chains.t>>),
     ))
 
-    if chains->Utils.Array.notEmpty {
-      let () =
-        await sql->Postgres.unsafe(
-          InternalTable.DynamicContractRegistry.makeCleanUpOnRestartQuery(~pgSchema, ~chains),
-        )
-    }
-
     {
       cleanRun: false,
       cache,

package/src/PgStorage.res.js

@@ -638,14 +638,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
           restoreEffectCache(false),
           sql.unsafe(makeLoadAllQuery(pgSchema, InternalTable.Chains.table.tableName))
         ]);
-    var chains = match[1];
-    if (Utils.$$Array.notEmpty(chains)) {
-      await sql.unsafe(InternalTable.DynamicContractRegistry.makeCleanUpOnRestartQuery(pgSchema, chains));
-    }
     return {
             cleanRun: false,
             cache: match[0],
-            chains: chains
+            chains: match[1]
           };
   };
   return {

package/src/Utils.res

@@ -70,6 +70,12 @@ module Dict = {
    */
   external dangerouslyGetNonOption: (dict<'a>, string) => option<'a> = ""
 
+  @get_index
+  /**
+    It's the same as `Js.Dict.get` but it doesn't have runtime overhead to check if the key exists.
+   */
+  external dangerouslyGetByIntNonOption: (dict<'a>, int) => option<'a> = ""
+
   let has: (dict<'a>, string) => bool = %raw(`(dict, key) => key in dict`)
 
   let push = (dict, key, value) => {
@@ -188,6 +194,10 @@ module Array = {
     }
   }
 
+  let clearInPlace: array<'a> => unit = %raw(`(arr) => {
+    arr.length = 0
+  }`)
+
   /**
   Creates a shallow copy of the array and sets the value at the given index
   */