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

package/src/HandlerRegister.res.mjs

@@ -1,27 +1,51 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_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";
 
-var eventRegistrations = {};
+let version = Utils.EnvioPackage.value.version;
+
+let existing = globalThis.__envioRegistry;
+
+let registry;
+
+if (existing == null) {
+  let fresh_eventRegistrations = {};
+  let fresh_activeRegistration = {
+    contents: undefined
+  };
+  let fresh_preRegistered = [];
+  let fresh = {
+    version: version,
+    eventRegistrations: fresh_eventRegistrations,
+    activeRegistration: fresh_activeRegistration,
+    preRegistered: fresh_preRegistered
+  };
+  globalThis.__envioRegistry = fresh;
+  registry = fresh;
+} else {
+  registry = existing.version === version ? existing : Stdlib_JsError.throwWithMessage(`Multiple incompatible envio versions loaded in the same process: ` + existing.version + ` and ` + version + `. Deduplicate the 'envio' dependency in your project.`);
+}
+
+let eventRegistrations = registry.eventRegistrations;
 
 function getKey(contractName, eventName) {
   return contractName + "." + eventName;
 }
 
 function get(contractName, eventName) {
-  var existing = eventRegistrations[getKey(contractName, eventName)];
+  let existing = eventRegistrations[getKey(contractName, eventName)];
   if (existing !== undefined) {
     return existing;
   } else {
     return {
-            handler: undefined,
-            contractRegister: undefined,
-            eventOptions: undefined
-          };
+      handler: undefined,
+      contractRegister: undefined,
+      eventOptions: undefined
+    };
   }
 }
 
@@ -29,28 +53,26 @@ function set(contractName, eventName, registration) {
   eventRegistrations[getKey(contractName, eventName)] = registration;
 }
 
-var activeRegistration = {
-  contents: undefined
-};
+let activeRegistration = registry.activeRegistration;
 
-var preRegistered = [];
+let preRegistered = registry.preRegistered;
 
 function withRegistration(fn) {
-  var r = activeRegistration.contents;
+  let r = activeRegistration.contents;
   if (r !== undefined) {
     if (r.finished) {
-      return Js_exn.raiseError("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
+      return Stdlib_JsError.throwWithMessage("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
     } else {
       return fn(r);
     }
   } else {
     preRegistered.push(fn);
-    return ;
+    return;
   }
 }
 
 function startRegistration(ecosystem, multichain) {
-  var r = {
+  let r = {
     ecosystem: ecosystem,
     multichain: multichain,
     registrations: {
@@ -59,27 +81,26 @@ function startRegistration(ecosystem, multichain) {
     finished: false
   };
   activeRegistration.contents = r;
-  while(preRegistered.length > 0) {
-    var fn = preRegistered.pop();
+  while (preRegistered.length !== 0) {
+    let fn = preRegistered.pop();
     if (fn !== undefined) {
       fn(r);
     }
-    
   };
 }
 
 function finishRegistration() {
-  var r = activeRegistration.contents;
+  let r = activeRegistration.contents;
   if (r !== undefined) {
     r.finished = true;
     return r.registrations;
   } else {
-    return Js_exn.raiseError("The indexer has not started registering handlers, so can't finish it.");
+    return Stdlib_JsError.throwWithMessage("The indexer has not started registering handlers, so can't finish it.");
   }
 }
 
 function isPendingRegistration() {
-  var r = activeRegistration.contents;
+  let r = activeRegistration.contents;
   if (r !== undefined) {
     return !r.finished;
   } else {
@@ -87,48 +108,36 @@ function isPendingRegistration() {
   }
 }
 
-var onBlockOptionsSchema = S$RescriptSchema.schema(function (s) {
-      return {
-              name: s.m(S$RescriptSchema.string),
-              chain: s.m(S$RescriptSchema.$$int),
-              interval: s.m(S$RescriptSchema.$$Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.$$int, 1, undefined)), 1)),
-              startBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
-              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
-            };
-    });
+function throwIfFinishedRegistration(methodName) {
+  let match = activeRegistration.contents;
+  if (match === undefined) {
+    return;
+  }
+  let match$1 = match.finished;
+  if (match$1) {
+    return Stdlib_JsError.throwWithMessage(`Cannot call \`indexer.` + methodName + `\` after the indexer has started. Make sure all handlers are registered at the top level of your handler module.`);
+  }
+}
 
-function onBlock(rawOptions, handler) {
-  withRegistration(function (registration) {
-        var match = registration.multichain;
-        if (match === "ordered") {
-          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
-        }
-        var options = S$RescriptSchema.parseOrThrow(rawOptions, onBlockOptionsSchema);
-        var chainId = options.chain;
-        var onBlockByChainId = registration.registrations.onBlockByChainId;
-        var onBlockConfigs = onBlockByChainId[String(chainId)];
-        if (onBlockConfigs !== undefined) {
-          onBlockConfigs.push({
-                index: onBlockConfigs.length,
-                name: options.name,
-                chainId: chainId,
-                startBlock: options.startBlock,
-                endBlock: options.endBlock,
-                interval: options.interval,
-                handler: handler
-              });
-        } else {
-          onBlockByChainId[chainId] = [{
-              index: 0,
-              name: options.name,
-              chainId: chainId,
-              startBlock: options.startBlock,
-              endBlock: options.endBlock,
-              interval: options.interval,
-              handler: handler
-            }];
-        }
-      });
+function registerOnBlock(name, chainId, interval, startBlock, endBlock, handler) {
+  withRegistration(registration => {
+    let match = registration.multichain;
+    if (match === "ordered") {
+      Stdlib_JsError.throwWithMessage("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
+    }
+    let onBlockByChainId = registration.registrations.onBlockByChainId;
+    let key = String(chainId);
+    let index = Belt_Option.mapWithDefault(onBlockByChainId[key], 0, configs => configs.length);
+    Utils.Dict.push(onBlockByChainId, key, {
+      index: index,
+      name: name,
+      chainId: chainId,
+      startBlock: startBlock,
+      endBlock: endBlock,
+      interval: interval,
+      handler: handler
+    });
+  });
 }
 
 function getHandler(contractName, eventName) {
@@ -139,20 +148,16 @@ function getContractRegister(contractName, eventName) {
   return get(contractName, eventName).contractRegister;
 }
 
-function getEventFilters(contractName, eventName) {
-  return Belt_Option.flatMap(get(contractName, eventName).eventOptions, (function (value) {
-                return value.eventFilters;
-              }));
+function getOnEventWhere(contractName, eventName) {
+  return Belt_Option.flatMap(get(contractName, eventName).eventOptions, value => value.where);
 }
 
 function isWildcard(contractName, eventName) {
-  return Belt_Option.getWithDefault(Belt_Option.flatMap(get(contractName, eventName).eventOptions, (function (value) {
-                    return value.wildcard;
-                  })), false);
+  return Belt_Option.getWithDefault(Belt_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
 }
 
 function hasRegistration(contractName, eventName) {
-  var r = get(contractName, eventName);
+  let r = get(contractName, eventName);
   if (Belt_Option.isSome(r.handler)) {
     return true;
   } else {
@@ -161,28 +166,26 @@ function hasRegistration(contractName, eventName) {
 }
 
 function raiseDuplicateRegistration(contractName, eventName, msg, logger) {
-  var fullMsg = msg + " for " + contractName + "." + eventName;
+  let fullMsg = msg + " for " + contractName + "." + eventName;
   Logging.childError(Logging.createChildFrom(logger, {
-            contractName: contractName,
-            eventName: eventName
-          }), fullMsg);
-  return Js_exn.raiseError(fullMsg);
+    contractName: contractName,
+    eventName: eventName
+  }), fullMsg);
+  return Stdlib_JsError.throwWithMessage(fullMsg);
 }
 
 function eventOptionsMatch(existing, incoming) {
   if (existing !== undefined) {
     if (incoming !== undefined && existing.wildcard === incoming.wildcard) {
-      var a = existing.eventFilters;
-      var b = incoming.eventFilters;
+      let a = existing.where;
+      let b = incoming.where;
       if (a !== undefined) {
-        if (a.TAG === "Static") {
-          if (b !== undefined && b.TAG === "Static") {
-            return Caml_obj.equal(a._0, b._0);
+        if (b !== undefined) {
+          if (typeof a === "function" || typeof b === "function") {
+            return a === b;
           } else {
-            return false;
+            return Primitive_object.equal(a, b);
           }
-        } else if (b !== undefined && b.TAG !== "Static") {
-          return a._0 === b._0;
         } else {
           return false;
         }
@@ -198,102 +201,99 @@ function eventOptionsMatch(existing, incoming) {
 }
 
 function setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
   if (eventOptions === undefined) {
-    return ;
+    return;
   }
-  var t = get(contractName, eventName);
-  var existingValue = t.eventOptions;
+  let t = get(contractName, eventName);
+  let existingValue = t.eventOptions;
   if (existingValue !== undefined) {
     if (!eventOptionsMatch(existingValue, eventOptions)) {
-      return raiseDuplicateRegistration(contractName, eventName, "Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)", logger);
+      return raiseDuplicateRegistration(contractName, eventName, "Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
     } else {
-      return ;
+      return;
     }
   } else {
     return set(contractName, eventName, {
-                handler: t.handler,
-                contractRegister: t.contractRegister,
-                eventOptions: eventOptions
-              });
+      handler: t.handler,
+      contractRegister: t.contractRegister,
+      eventOptions: eventOptions
+    });
   }
 }
 
 function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (_registration) {
-        var t = get(contractName, eventName);
-        var prevHandler = t.handler;
-        if (prevHandler !== undefined) {
-          var incomingEventOptions = Belt_Option.map(eventOptions, (function (v) {
-                  return 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, eventFilters)", logger);
-          }
-          var composedHandler = async function (args) {
-            await prevHandler(args);
-            return await handler(args);
-          };
-          return set(contractName, eventName, {
-                      handler: composedHandler,
-                      contractRegister: t.contractRegister,
-                      eventOptions: t.eventOptions
-                    });
-        }
-        setEventOptions(contractName, eventName, eventOptions, logger);
-        var t$1 = get(contractName, eventName);
-        set(contractName, eventName, {
-              handler: handler,
-              contractRegister: t$1.contractRegister,
-              eventOptions: t$1.eventOptions
-            });
+  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  withRegistration(_registration => {
+    let t = get(contractName, eventName);
+    let prevHandler = t.handler;
+    if (prevHandler !== undefined) {
+      let incomingEventOptions = Belt_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);
+      }
+      let composedHandler = async args => {
+        await prevHandler(args);
+        return await handler(args);
+      };
+      return set(contractName, eventName, {
+        handler: composedHandler,
+        contractRegister: t.contractRegister,
+        eventOptions: t.eventOptions
       });
+    }
+    setEventOptions(contractName, eventName, eventOptions, logger);
+    let t$1 = get(contractName, eventName);
+    set(contractName, eventName, {
+      handler: handler,
+      contractRegister: t$1.contractRegister,
+      eventOptions: t$1.eventOptions
+    });
+  });
 }
 
 function setContractRegister(contractName, eventName, contractRegister, eventOptions, loggerOpt) {
-  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (_registration) {
-        var t = get(contractName, eventName);
-        var prevContractRegister = t.contractRegister;
-        if (prevContractRegister !== undefined) {
-          var incomingEventOptions = Belt_Option.map(eventOptions, (function (v) {
-                  return 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, eventFilters)", logger);
-          }
-          var composedContractRegister = async function (args) {
-            await prevContractRegister(args);
-            return await contractRegister(args);
-          };
-          return set(contractName, eventName, {
-                      handler: t.handler,
-                      contractRegister: composedContractRegister,
-                      eventOptions: t.eventOptions
-                    });
-        }
-        setEventOptions(contractName, eventName, eventOptions, logger);
-        var t$1 = get(contractName, eventName);
-        set(contractName, eventName, {
-              handler: t$1.handler,
-              contractRegister: contractRegister,
-              eventOptions: t$1.eventOptions
-            });
+  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  withRegistration(_registration => {
+    let t = get(contractName, eventName);
+    let prevContractRegister = t.contractRegister;
+    if (prevContractRegister !== undefined) {
+      let incomingEventOptions = Belt_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);
+      }
+      let composedContractRegister = async args => {
+        await prevContractRegister(args);
+        return await contractRegister(args);
+      };
+      return set(contractName, eventName, {
+        handler: t.handler,
+        contractRegister: composedContractRegister,
+        eventOptions: t.eventOptions
       });
+    }
+    setEventOptions(contractName, eventName, eventOptions, logger);
+    let t$1 = get(contractName, eventName);
+    set(contractName, eventName, {
+      handler: t$1.handler,
+      contractRegister: contractRegister,
+      eventOptions: t$1.eventOptions
+    });
+  });
 }
 
 export {
-  startRegistration ,
-  isPendingRegistration ,
-  finishRegistration ,
-  setHandler ,
-  setContractRegister ,
-  getHandler ,
-  getContractRegister ,
-  getEventFilters ,
-  isWildcard ,
-  hasRegistration ,
-  onBlock ,
+  startRegistration,
+  isPendingRegistration,
+  finishRegistration,
+  throwIfFinishedRegistration,
+  setHandler,
+  setContractRegister,
+  getHandler,
+  getContractRegister,
+  getOnEventWhere,
+  isWildcard,
+  hasRegistration,
+  registerOnBlock,
 }
-/* onBlockOptionsSchema Not a pure module */
+/* existing Not a pure module */

package/src/HandlerRegister.resi

@@ -3,19 +3,20 @@ type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
 let startRegistration: (~ecosystem: Ecosystem.t, ~multichain: Internal.multichain) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: unit => registrations
+let throwIfFinishedRegistration: (~methodName: string) => unit
 
 let setHandler: (
   ~contractName: string,
   ~eventName: string,
   Internal.genericHandler<Internal.genericHandlerArgs<'event, Internal.handlerContext>>,
-  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~eventOptions: option<Internal.eventOptions<'where>>,
   ~logger: Pino.t=?,
 ) => unit
 let setContractRegister: (
   ~contractName: string,
   ~eventName: string,
   Internal.genericContractRegister<Internal.genericContractRegisterArgs<'event, 'context>>,
-  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~eventOptions: option<Internal.eventOptions<'where>>,
   ~logger: Pino.t=?,
 ) => unit
 let getHandler: (~contractName: string, ~eventName: string) => option<Internal.handler>
@@ -23,8 +24,15 @@ let getContractRegister: (
   ~contractName: string,
   ~eventName: string,
 ) => option<Internal.contractRegister>
-let getEventFilters: (~contractName: string, ~eventName: string) => option<Js.Json.t>
+let getOnEventWhere: (~contractName: string, ~eventName: string) => option<JSON.t>
 let isWildcard: (~contractName: string, ~eventName: string) => bool
 let hasRegistration: (~contractName: string, ~eventName: string) => bool
 
-let onBlock: (unknown, Internal.onBlockArgs => promise<unit>) => unit
+let registerOnBlock: (
+  ~name: string,
+  ~chainId: int,
+  ~interval: int,
+  ~startBlock: option<int>,
+  ~endBlock: option<int>,
+  ~handler: Internal.onBlockArgs => promise<unit>,
+) => unit

package/src/Hasura.res

@@ -27,7 +27,14 @@ let clearMetadataRoute = Rest.route(() => {
   path: "",
   input: s => {
     let _ = s.field("type", S.literal("clear_metadata"))
-    let _ = s.field("args", S.literal(Js.Obj.empty()))
+    let _ = s.field(
+      "args",
+      S.literal(
+        Object.make(),
+
+        // Otherwise the entity in gql will be prefixed with the schema name (when it's not public)
+      ),
+    )
     s->auth
   },
   responses,
@@ -58,13 +65,13 @@ let rawBodyRoute = Rest.route(() => {
   responses,
 })
 
-let sendOperation = async (~endpoint, ~auth, ~operation: Js.Json.t) => {
+let sendOperation = async (~endpoint, ~auth, ~operation: JSON.t) => {
   let maxRetries = 3
   let rec retry = async (~attempt) => {
     try {
       let _ = await rawBodyRoute->Rest.fetch(
         {
-          "bodyString": operation->Js.Json.stringify,
+          "bodyString": operation->JSON.stringify,
           "auth": auth,
         },
         ~client=Rest.client(endpoint),
@@ -72,7 +79,7 @@ let sendOperation = async (~endpoint, ~auth, ~operation: Js.Json.t) => {
     } catch {
     | exn =>
       if attempt < maxRetries {
-        let backoffMs = Js.Math.pow_float(~base=2.0, ~exp=attempt->Belt.Int.toFloat)->Belt.Float.toInt * 1000
+        let backoffMs = Math.pow(2.0, ~exp=attempt->Belt.Int.toFloat)->Belt.Float.toInt * 1000
         await Time.resolvePromiseAfterDelay(~delayMilliseconds=backoffMs)
         await retry(~attempt=attempt + 1)
       } else {
@@ -111,19 +118,18 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>
         "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": tableNames->Js.Array2.map(tableName =>
+          "tables": tableNames->Array.map(tableName =>
             {
               "table": {
                 "name": tableName,
                 "schema": pgSchema,
               },
               "configuration": {
-                // Otherwise the entity in gql will be prefixed with the schema name (when it's not public)
                 "custom_name": tableName,
               },
             }
           ),
-        }->(Utils.magic: 'a => Js.Json.t),
+        }->(Utils.magic: 'a => JSON.t),
       },
       ~client=Rest.client(endpoint),
     )
@@ -167,12 +173,12 @@ let createSelectPermission = async (
         "source": "default",
         "permission": {
           "columns": "*",
-          "filter": Js.Obj.empty(),
+          "filter": Object.make(),
           "limit": responseLimit,
-          "allow_aggregations": aggregateEntities->Js.Array2.includes(tableName),
+          "allow_aggregations": aggregateEntities->Array.includes(tableName),
         },
       },
-    }->(Utils.magic: 'a => Js.Json.t),
+    }->(Utils.magic: 'a => JSON.t),
   )
 }
 
@@ -207,11 +213,11 @@ let createEntityRelationship = async (
               "schema": pgSchema,
               "name": mappedEntity,
             },
-            "column_mapping": Js.Json.parseExn(`{${derivedFromTo}}`),
+            "column_mapping": JSON.parseOrThrow(`{${derivedFromTo}}`),
           },
         },
       },
-    }->(Utils.magic: 'a => Js.Json.t),
+    }->(Utils.magic: 'a => JSON.t),
   )
 }
 
@@ -229,7 +235,7 @@ let trackDatabase = async (
     InternalTable.Views.metaViewName,
     InternalTable.Views.chainMetadataViewName,
   ]
-  let userTableNames = userEntities->Js.Array2.map(entity => entity.table.tableName)
+  let userTableNames = userEntities->Array.map(entity => entity.table.tableName)
   let tableNames = [exposedInternalTableNames, userTableNames]->Belt.Array.concatMany
 
   Logging.info("Tracking tables in Hasura")
@@ -238,19 +244,26 @@ let trackDatabase = async (
 
   await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
 
-  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)
+  for i in 0 to tableNames->Array.length - 1 {
+    let tableName = tableNames->Array.getUnsafe(i)
+    await createSelectPermission(
+      ~endpoint,
+      ~auth,
+      ~tableName,
+      ~pgSchema,
+      ~responseLimit,
+      ~aggregateEntities,
+    )
   }
 
-  for i in 0 to userEntities->Js.Array2.length - 1 {
-    let entityConfig = userEntities->Js.Array2.unsafe_get(i)
+  for i in 0 to userEntities->Array.length - 1 {
+    let entityConfig = userEntities->Array.getUnsafe(i)
     let {tableName} = entityConfig.table
 
     //Set array relationships
     let derivedFromFields = entityConfig.table->Table.getDerivedFromFields
-    for j in 0 to derivedFromFields->Js.Array2.length - 1 {
-      let derivedFromField = derivedFromFields->Js.Array2.unsafe_get(j)
+    for j in 0 to derivedFromFields->Array.length - 1 {
+      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
@@ -270,8 +283,8 @@ let trackDatabase = async (
 
     //Set object relationships
     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)
+    for j in 0 to linkedEntityFields->Array.length - 1 {
+      let (field, linkedEntityName) = linkedEntityFields->Array.getUnsafe(j)
       await createEntityRelationship(
         ~endpoint,
         ~auth,