envio 3.5.0 → 3.5.1-svm-alpha.2

package/src/FetchState.res

@@ -690,13 +690,19 @@ module OptimizedPartitions = {
     // Update density for every response, independently from whether this range
     // is valid evidence of source capacity. A cap hit is still useful density
     // evidence because it reports items returned across the scanned range.
-    let observedEventDensity = itemsCount->Int.toFloat /. blockRange->Int.toFloat
-    // Seed from the first observation, then smooth every later observation
-    // with a 1:1 moving average. Keeping initialization explicit is important:
-    // zero is valid density evidence and must participate in the next blend.
-    let updatedEventDensity = switch p.eventDensity {
-    | None => Some(observedEventDensity)
-    | Some(eventDensity) => Some((eventDensity +. observedEventDensity) /. 2.)
+    // A response that didn't advance covers no range at all — skip it, or the
+    // 0/0 division would latch the moving average at NaN permanently.
+    let updatedEventDensity = if blockRange <= 0 {
+      p.eventDensity
+    } else {
+      let observedEventDensity = itemsCount->Int.toFloat /. blockRange->Int.toFloat
+      // Seed from the first observation, then smooth every later observation
+      // with a 1:1 moving average. Keeping initialization explicit is important:
+      // zero is valid density evidence and must participate in the next blend.
+      switch p.eventDensity {
+      | None => Some(observedEventDensity)
+      | Some(eventDensity) => Some((eventDensity +. observedEventDensity) /. 2.)
+      }
     }
 
     // Skip updating source capacity if a later response already updated it.
@@ -1473,7 +1479,7 @@ let warnRejectedRegistration = (
       ~params={"contractName": contractName},
       `Skipping contract registration: Not a valid address for this chain's ecosystem.`,
     )
-  | Added(_) | NoEvents(_) => ()
+  | Added(_) => ()
   }
 
 /**
@@ -1678,9 +1684,9 @@ let registerDynamicContracts = (
   // height in here. Defaults to what the fetch state knows, which is all
   // there is to go on when no response is being applied.
   ~claimCeiling=fetchState.knownHeight,
-  // These are raw items which might have dynamic contracts received from contractRegister call.
-  // Might contain duplicates which we should filter out
-  items: array<Internal.item>,
+  // Registrations collected from contractRegister calls, in the order the
+  // handlers made them. May contain duplicates, which the store filters out.
+  registrations: array<AddressStore.registration>,
 ) => {
   if fetchState.normalSelection.onEventRegistrations->Utils.Array.isEmpty {
     // Can the normalSelection be empty?
@@ -1689,91 +1695,42 @@ let registerDynamicContracts = (
     )
   }
 
-  // Flatten every item's dcs into one batch, remembering where each came from
-  // so the rejected ones can be spliced back out of their item (which is what
-  // keeps them from being persisted twice).
-  let registrations: array<AddressStore.registration> = []
-  let sourceDcs: array<Internal.dcs> = []
-  let sourceIndexes: array<int> = []
-  for itemIdx in 0 to items->Array.length - 1 {
-    switch items->Array.getUnsafe(itemIdx)->Internal.getItemDcs {
-    | None => ()
-    | Some(dcs) =>
-      for dcIdx in 0 to dcs->Array.length - 1 {
-        let dc = dcs->Array.getUnsafe(dcIdx)
-        registrations
-        ->Array.push({
-          address: dc.address,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock,
-        })
-        ->ignore
-        sourceDcs->Array.push(dcs)->ignore
-        sourceIndexes->Array.push(dcIdx)->ignore
-      }
-    }
-  }
-
   // Ids are handed out in registration order, so a cursor taken now selects
   // exactly what this batch adds.
   let idCursor = addressStore->AddressStore.nextId
   // The store resolves each address against both what it already holds and the
   // batch's own earlier entries, so two contracts claiming one address inside a
-  // single batch conflict the same way as across batches.
+  // single batch conflict the same way as across batches. It also decides which
+  // additions this chain fetches for, since it's what holds the contract list.
   let verdicts = addressStore->AddressStore.registerBatch(registrations)
 
   let registeringContractNames = []
-  let hasNoEventsUpdatesRef = ref(false)
   for idx in 0 to verdicts->Array.length - 1 {
     let registration = registrations->Array.getUnsafe(idx)
     let verdict = verdicts->Array.getUnsafe(idx)
-    let keep = switch verdict {
-    | Added(_) =>
+    switch verdict {
+    | Added({fetchable: true}) =>
       if !(registeringContractNames->Array.includes(registration.contractName)) {
         registeringContractNames->Array.push(registration.contractName)->ignore
       }
-      true
-    | NoEvents(_) =>
-      hasNoEventsUpdatesRef := true
-      // Persist the address to the db so a future config change that adds
-      // events for this contract can pick it up on restart, but skip partition
-      // registration since there's nothing to fetch.
-      warnAddressRegistration(
-        ~chainId=fetchState.chainId,
-        ~contractAddress=registration.address,
-        ~params={"contractName": registration.contractName},
-        `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`,
-      )
-      true
+    // Nothing on this chain is fetched by address for the contract, so there's
+    // no partition to build. The address is still stored and persisted, so a
+    // config that later adds address-dependent events picks it up on restart.
+    | Added({fetchable: false}) => ()
     | Conflict(_) | Duplicate(_) | Invalid =>
       verdict->warnRejectedRegistration(
         ~chainId=fetchState.chainId,
         ~contractAddress=registration.address,
         ~contractName=registration.contractName,
       )
-      false
-    }
-    if !keep {
-      // Mark for removal; the splice happens below, back to front, so earlier
-      // indexes stay valid.
-      sourceIndexes->Array.setUnsafe(idx, -1 - sourceIndexes->Array.getUnsafe(idx))
-    }
-  }
-  for idx in verdicts->Array.length - 1 downto 0 {
-    let marked = sourceIndexes->Array.getUnsafe(idx)
-    if marked < 0 {
-      let _ =
-        sourceDcs->Array.getUnsafe(idx)->Array.splice(~start=-1 - marked, ~remove=1, ~insert=[])
     }
   }
 
-  switch (registeringContractNames, hasNoEventsUpdatesRef.contents) {
-  // Dont update anything when everything was filtered out
-  | ([], false) => fetchState
-  // Only dcs for contracts without events. The store already tracks them so
-  // subsequent registrations see them, but there are no partitions to touch.
-  | ([], true) => fetchState
-  | (_, _) => {
+  switch registeringContractNames {
+  // Nothing to fetch: everything was rejected, or registered for contracts
+  // this chain has no address-dependent events for.
+  | [] => fetchState
+  | _ => {
       let newPartitions = []
       let dynamicContractsRef = ref(fetchState.optimizedPartitions.dynamicContracts)
       let mutExistingPartitions = fetchState.optimizedPartitions.entities->Dict.valuesToArray
@@ -1835,7 +1792,11 @@ let registerDynamicContracts = (
                         dynamicContract: Some(contractName),
                         addresses: splitAddresses,
                         mergeBlock: None,
-                        mutPendingQueries: p.mutPendingQueries,
+                        // Must be a fresh array: sharing p's (empty) queue by
+                        // reference lets both split halves push and consume in
+                        // one array, so one half can consume the other's
+                        // fetched range and skip it for its own addresses.
+                        mutPendingQueries: [],
                         sourceRangeCapacity: p.sourceRangeCapacity,
                         prevSourceRangeCapacity: p.prevSourceRangeCapacity,
                         eventDensity: p.eventDensity,
@@ -2709,7 +2670,9 @@ let make = (
   // contract has no address-dependent events, so a later registration of the
   // same address still conflicts and the address is still persisted.
   addressStore
-  ->AddressStore.registerBatch(
+  // These come from the config or from a resume, so they're already stored and
+  // must never be drained back into a write.
+  ->AddressStore.seedBatch(
     addresses->Array.map((contract): AddressStore.registration => {
       address: contract.address,
       contractName: contract.contractName,

package/src/FetchState.res.mjs

@@ -532,9 +532,14 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
   let pendingQuery = getPendingQueryOrThrow(p, query.fromBlock);
   pendingQuery.fetchedBlock = latestFetchedBlock;
   let blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
-  let observedEventDensity = itemsCount / blockRange;
-  let eventDensity = p.eventDensity;
-  let updatedEventDensity = eventDensity !== undefined ? (eventDensity + observedEventDensity) / 2 : observedEventDensity;
+  let updatedEventDensity;
+  if (blockRange <= 0) {
+    updatedEventDensity = p.eventDensity;
+  } else {
+    let observedEventDensity = itemsCount / blockRange;
+    let eventDensity = p.eventDensity;
+    updatedEventDensity = eventDensity !== undefined ? (eventDensity + observedEventDensity) / 2 : observedEventDensity;
+  }
   let shouldUpdateSourceRangeCapacity = false;
   if (latestFetchedBlock.blockNumber > p.latestSourceRangeCapacityUpdateBlock) {
     let queryToBlock = query.toBlock;
@@ -1086,7 +1091,6 @@ function warnRejectedRegistration(verdict, chainId, contractAddress, contractNam
   }
   switch (verdict.TAG) {
     case "Added" :
-    case "NoEvents" :
       return;
     case "Duplicate" :
       let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
@@ -1225,71 +1229,25 @@ function createPartitions(registeringSetsByContract, addressStore, dynamicContra
   return make(allPartitions, maxAddrInPartition, nextPartitionIndexRef.contents, dynamicContracts, clientFilteredContracts);
 }
 
-function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, items) {
+function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, registrations) {
   let claimCeiling = claimCeilingOpt !== undefined ? claimCeilingOpt : fetchState.knownHeight;
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.onEventRegistrations)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  let registrations = [];
-  let sourceDcs = [];
-  let sourceIndexes = [];
-  for (let itemIdx = 0, itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx) {
-    let dcs = items[itemIdx].dcs;
-    if (dcs !== undefined) {
-      for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
-        let dc = dcs[dcIdx];
-        registrations.push({
-          address: dc.address,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock
-        });
-        sourceDcs.push(dcs);
-        sourceIndexes.push(dcIdx);
-      }
-    }
-  }
   let idCursor = addressStore.nextId();
   let verdicts = AddressStore.registerBatch(addressStore, registrations);
   let registeringContractNames = [];
-  let hasNoEventsUpdatesRef = false;
   for (let idx = 0, idx_finish = verdicts.length; idx < idx_finish; ++idx) {
     let registration = registrations[idx];
     let verdict = verdicts[idx];
-    let keep;
     let exit = 0;
-    if (typeof verdict !== "object") {
+    if (typeof verdict !== "object" || verdict.TAG !== "Added") {
       exit = 1;
-    } else {
-      switch (verdict.TAG) {
-        case "Added" :
-          if (!registeringContractNames.includes(registration.contractName)) {
-            registeringContractNames.push(registration.contractName);
-          }
-          keep = true;
-          break;
-        case "NoEvents" :
-          hasNoEventsUpdatesRef = true;
-          warnAddressRegistration(fetchState.chainId, registration.address, {
-            contractName: registration.contractName
-          }, `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`);
-          keep = true;
-          break;
-        default:
-          exit = 1;
-      }
+    } else if (verdict.fetchable && !registeringContractNames.includes(registration.contractName)) {
+      registeringContractNames.push(registration.contractName);
     }
     if (exit === 1) {
       warnRejectedRegistration(verdict, fetchState.chainId, registration.address, registration.contractName);
-      keep = false;
-    }
-    if (!keep) {
-      sourceIndexes[idx] = -1 - sourceIndexes[idx] | 0;
-    }
-  }
-  for (let idx$1 = verdicts.length - 1 | 0; idx$1 >= 0; --idx$1) {
-    let marked = sourceIndexes[idx$1];
-    if (marked < 0) {
-      sourceDcs[idx$1].splice(-1 - marked | 0, 1);
     }
   }
   if (registeringContractNames.length === 0) {
@@ -1298,12 +1256,12 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
   let newPartitions = [];
   let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
   let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
-  for (let idx$2 = 0, idx_finish$1 = registeringContractNames.length; idx$2 < idx_finish$1; ++idx$2) {
-    let contractName = registeringContractNames[idx$2];
+  for (let idx$1 = 0, idx_finish$1 = registeringContractNames.length; idx$1 < idx_finish$1; ++idx$1) {
+    let contractName = registeringContractNames[idx$1];
     if (!dynamicContractsRef.has(contractName)) {
       dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
-      for (let idx$3 = 0, idx_finish$2 = mutExistingPartitions.length; idx$3 < idx_finish$2; ++idx$3) {
-        let p = mutExistingPartitions[idx$3];
+      for (let idx$2 = 0, idx_finish$2 = mutExistingPartitions.length; idx$2 < idx_finish$2; ++idx$2) {
+        let p = mutExistingPartitions[idx$2];
         let match = p.addresses.countFor(contractName);
         if (match !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
           let allPartitionContractNames = p.addresses.contractNames();
@@ -1312,7 +1270,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
             if (!isFetching) {
               let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
               let restNames = allPartitionContractNames.filter(name => name !== contractName);
-              mutExistingPartitions[idx$3] = withAddresses(p, p.addresses.filterByContracts(restNames));
+              mutExistingPartitions[idx$2] = withAddresses(p, p.addresses.filterByContracts(restNames));
               let splitAddresses = p.addresses.filterByContracts([contractName]);
               newPartitions.push({
                 id: newPartitionId,
@@ -1321,7 +1279,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
                 addresses: splitAddresses,
                 mergeBlock: undefined,
                 dynamicContract: contractName,
-                mutPendingQueries: p.mutPendingQueries,
+                mutPendingQueries: [],
                 sourceRangeCapacity: p.sourceRangeCapacity,
                 prevSourceRangeCapacity: p.prevSourceRangeCapacity,
                 eventDensity: p.eventDensity,
@@ -1329,7 +1287,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
               });
             }
           } else {
-            mutExistingPartitions[idx$3] = {
+            mutExistingPartitions[idx$2] = {
               id: p.id,
               latestFetchedBlock: p.latestFetchedBlock,
               selection: p.selection,
@@ -1786,7 +1744,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     });
   }
   let normalSelection = makeSelection(normalRegistrations, true, undefined);
-  AddressStore.registerBatch(addressStore, addresses.map(contract => ({
+  AddressStore.seedBatch(addressStore, addresses.map(contract => ({
     address: contract.address,
     contractName: contract.contractName,
     registrationBlock: contract.registrationBlock

package/src/Hasura.res

@@ -281,6 +281,21 @@ let createSelectPermission = async (
   )
 }
 
+// The column_mapping references columns by their db names. A reference between
+// two per-chain entities is only meaningful within one chain, so the chain-id
+// column joins alongside the id — without it the relationship would resolve to
+// another chain's row with the same id.
+let makeColumnMapping = (~relationalKey, ~isDerivedFrom, ~chainIdColumn) => {
+  let pairs = [
+    isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}": "id"`,
+  ]
+  switch chainIdColumn {
+  | Some(column) => pairs->Array.push(`"${column}": "${column}"`)->ignore
+  | None => ()
+  }
+  `{${pairs->Array.joinUnsafe(", ")}}`
+}
+
 let createEntityRelationship = async (
   ~endpoint,
   ~auth,
@@ -291,10 +306,9 @@ let createEntityRelationship = async (
   ~objectName: string,
   ~mappedEntity: string,
   ~isDerivedFrom: bool,
+  ~chainIdColumn: option<string>,
   ~comment: option<string>=?,
 ) => {
-  // The column_mapping references columns by their db names
-  let derivedFromTo = isDerivedFrom ? `"id": "${relationalKey}"` : `"${relationalKey}" : "id"`
 
   let tableJson = {
     "schema": pgSchema,
@@ -306,7 +320,9 @@ let createEntityRelationship = async (
         "schema": pgSchema,
         "name": mappedEntity,
       },
-      "column_mapping": JSON.parseOrThrow(`{${derivedFromTo}}`),
+      "column_mapping": JSON.parseOrThrow(
+        makeColumnMapping(~relationalKey, ~isDerivedFrom, ~chainIdColumn),
+      ),
     },
   }->(Utils.magic: {..} => JSON.t)
 
@@ -388,9 +404,25 @@ let trackDatabase = async (
     )
   }
 
+  // Both sides of a relationship must be per-chain for the chain to be part of
+  // the join; a per-chain entity referencing a cross-chain one resolves by id
+  // alone. The reverse (cross-chain referencing per-chain) is rejected at
+  // codegen, so it can't reach here.
+  let chainIdColumnOf = (entityName: string) =>
+    userEntities
+    ->Array.find((e: Internal.entityConfig) => e.name === entityName)
+    ->Option.flatMap(e => e.table->Table.getChainIdField)
+    ->Option.map(Table.getPgDbFieldName)
+
   for i in 0 to userEntities->Array.length - 1 {
     let entityConfig = userEntities->Array.getUnsafe(i)
     let {tableName} = entityConfig.table
+    let ownChainIdColumn = entityConfig.table->Table.getChainIdField->Option.map(Table.getPgDbFieldName)
+    let sharedChainIdColumn = mappedEntity =>
+      switch (ownChainIdColumn, chainIdColumnOf(mappedEntity)) {
+      | (Some(column), Some(_)) => Some(column)
+      | _ => None
+      }
 
     //Set array relationships
     let derivedFromFields = entityConfig.table->Table.getDerivedFromFields
@@ -410,6 +442,7 @@ let trackDatabase = async (
         ~objectName=derivedFromField.fieldName,
         ~relationalKey=relationalFieldName,
         ~mappedEntity=derivedFromField.derivedFromEntity,
+        ~chainIdColumn=sharedChainIdColumn(derivedFromField.derivedFromEntity),
         ~comment=?derivedFromField.description,
       )
     }
@@ -428,6 +461,7 @@ let trackDatabase = async (
         ~objectName=field.fieldName,
         ~relationalKey=field->Table.getPgDbFieldName,
         ~mappedEntity=linkedEntityName,
+        ~chainIdColumn=sharedChainIdColumn(linkedEntityName),
         ~comment=?field.description,
       )
     }

package/src/Hasura.res.mjs

@@ -7,6 +7,7 @@ import * as Utils from "./Utils.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -247,8 +248,15 @@ async function createSelectPermission(endpoint, auth, tableName, pgSchema, respo
   });
 }
 
-async function createEntityRelationship(endpoint, auth, pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom, comment) {
-  let derivedFromTo = isDerivedFrom ? `"id": "` + relationalKey + `"` : `"` + relationalKey + `" : "id"`;
+function makeColumnMapping(relationalKey, isDerivedFrom, chainIdColumn) {
+  let pairs = [isDerivedFrom ? `"id": "` + relationalKey + `"` : `"` + relationalKey + `": "id"`];
+  if (chainIdColumn !== undefined) {
+    pairs.push(`"` + chainIdColumn + `": "` + chainIdColumn + `"`);
+  }
+  return `{` + pairs.join(", ") + `}`;
+}
+
+async function createEntityRelationship(endpoint, auth, pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom, chainIdColumn, comment) {
   let tableJson = {
     schema: pgSchema,
     name: tableName
@@ -259,7 +267,7 @@ async function createEntityRelationship(endpoint, auth, pgSchema, tableName, rel
         schema: pgSchema,
         name: mappedEntity
       },
-      column_mapping: JSON.parse(`{` + derivedFromTo + `}`)
+      column_mapping: JSON.parse(makeColumnMapping(relationalKey, isDerivedFrom, chainIdColumn))
     }
   };
   let args = {
@@ -313,21 +321,30 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
     let tableName = tableNames[i];
     await createSelectPermission(endpoint, auth, tableName, pgSchema, responseLimit, aggregateEntities);
   }
+  let chainIdColumnOf = entityName => Stdlib_Option.map(Stdlib_Option.flatMap(userEntities.find(e => e.name === entityName), e => Table.getChainIdField(e.table)), Table.getPgDbFieldName);
   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 ownChainIdColumn = Stdlib_Option.map(Table.getChainIdField(entityConfig.table), Table.getPgDbFieldName);
+    let sharedChainIdColumn = mappedEntity => {
+      let match = chainIdColumnOf(mappedEntity);
+      if (ownChainIdColumn !== undefined && match !== undefined) {
+        return ownChainIdColumn;
+      }
+    };
     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.getDerivedFromPgFieldName(schema, derivedFromField));
-      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true, derivedFromField.description);
+      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true, sharedChainIdColumn(derivedFromField.derivedFromEntity), derivedFromField.description);
     }
     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 linkedEntityName = match$1[1];
       let field = match$1[0];
-      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", Table.getPgDbFieldName(field), field.fieldName, match$1[1], false, field.description);
+      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", Table.getPgDbFieldName(field), field.fieldName, linkedEntityName, false, sharedChainIdColumn(linkedEntityName), field.description);
     }
   }
   return Logging.info("Hasura configuration completed");
@@ -346,6 +363,7 @@ export {
   makeColumnConfigs,
   trackTables,
   createSelectPermission,
+  makeColumnMapping,
   createEntityRelationship,
   trackDatabase,
 }