envio 3.1.2 → 3.2.1

package/src/Persistence.res

@@ -40,8 +40,6 @@ type initialState = {
   envioInfo: option<JSON.t>,
 }
 
-type operator = [#">" | #"=" | #"<"]
-
 type updatedEffectCache = {
   effect: Internal.effect,
   items: array<Internal.effectCacheItem>,
@@ -78,21 +76,10 @@ type storage = {
     ~envioInfo: JSON.t,
   ) => promise<initialState>,
   resumeInitialState: unit => promise<initialState>,
+  // Returns rows matching the filter.
+  // Field values are serialized and rows parsed with the table's field schemas.
   @raises("StorageError")
-  loadByIdsOrThrow: 'item. (
-    ~ids: array<string>,
-    ~table: Table.table,
-    ~rowsSchema: S.t<array<'item>>,
-  ) => promise<array<'item>>,
-  @raises("StorageError")
-  loadByFieldOrThrow: 'item 'value. (
-    ~fieldName: string,
-    ~fieldSchema: S.t<'value>,
-    ~fieldValue: 'value,
-    ~operator: operator,
-    ~table: Table.table,
-    ~rowsSchema: S.t<array<'item>>,
-  ) => promise<array<'item>>,
+  loadOrThrow: (~filter: EntityFilter.t, ~table: Table.table) => promise<array<unknown>>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
   reset: unit => promise<unit>,

package/src/PgStorage.res

@@ -26,7 +26,7 @@ let makeCreateIndexQuery = (~tableName, ~indexFields, ~pgSchema) => {
   let indexName = tableName ++ "_" ++ indexFields->Array.joinUnsafe("_")
 
   // Case for indexer before envio@2.28
-  let index = indexFields->Belt.Array.map(idx => `"${idx}"`)->Array.joinUnsafe(", ")
+  let index = indexFields->Array.map(idx => `"${idx}"`)->Array.joinUnsafe(", ")
   `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${pgSchema}"."${tableName}"(${index});`
 }
 
@@ -55,7 +55,7 @@ let makeCreateCompositeIndexQuery = (
     ->Array.joinUnsafe("_")
   let index =
     indexFields
-    ->Belt.Array.map(f => `"${f.fieldName}"${directionToSql(f.direction)}`)
+    ->Array.map(f => `"${f.fieldName}"${directionToSql(f.direction)}`)
     ->Array.joinUnsafe(", ")
   `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${pgSchema}"."${tableName}"(${index});`
 }
@@ -81,7 +81,7 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema, ~isNumericArrayAsText
     ->Table.getFields
     ->Array.map(field => {
       let {fieldType, isNullable, isArray, defaultValue} = field
-      let fieldName = field->Table.getDbFieldName
+      let fieldName = field->Table.getPgDbFieldName
 
       {
         `"${fieldName}" ${Table.getPgFieldType(
@@ -98,7 +98,7 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema, ~isNumericArrayAsText
     })
     ->Array.joinUnsafe(", ")
 
-  let primaryKeyFieldNames = table->Table.getPrimaryKeyFieldNames
+  let primaryKeyFieldNames = table->Table.getPgPrimaryKeyFieldNames
   let primaryKey = primaryKeyFieldNames->Array.map(field => `"${field}"`)->Array.joinUnsafe(", ")
 
   `CREATE TABLE IF NOT EXISTS "${pgSchema}"."${table.tableName}"(${fieldsMapped}${primaryKeyFieldNames->Array.length > 0
@@ -116,7 +116,7 @@ let getEntityHistory = (~entityConfig: Internal.entityConfig): EntityHistory.pgE
     let cache = {
       let id = "id"
 
-      let dataFields = entityConfig.table.fields->Belt.Array.keepMap(field =>
+      let dataFields = entityConfig.table.fields->Array.filterMap(field =>
         switch field {
         | Field(field) =>
           switch field.fieldName {
@@ -157,7 +157,7 @@ let getEntityHistory = (~entityConfig: Internal.entityConfig): EntityHistory.pgE
       //ignore composite indices
       let table = Table.mkTable(
         historyTableName,
-        ~fields=dataFields->Belt.Array.concat([checkpointIdField, actionField]),
+        ~fields=dataFields->Array.concat([checkpointIdField, actionField]),
       )
 
       let setChangeSchema = EntityHistory.makeSetUpdateSchema(entityConfig.schema)
@@ -245,7 +245,7 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
     ->Table.getDerivedFromFields
     ->Array.forEach(derivedFromField => {
       let indexField =
-        derivedSchema->Schema.getDerivedFromFieldName(derivedFromField)->Utils.unwrapResultExn
+        derivedSchema->Schema.getDerivedFromPgFieldName(derivedFromField)->Utils.unwrapResultExn
       query :=
         query.contents ++
         "\n" ++
@@ -281,16 +281,82 @@ $$ LANGUAGE plpgsql;`,
   ]
 }
 
-let makeLoadByIdQuery = (~pgSchema, ~tableName) => {
-  `SELECT * FROM "${pgSchema}"."${tableName}" WHERE id = $1 LIMIT 1;`
+let makeLoadQuery = (~pgSchema, ~tableName, ~condition) => {
+  `SELECT * FROM "${pgSchema}"."${tableName}" WHERE ${condition};`
 }
 
-let makeLoadByFieldQuery = (~pgSchema, ~tableName, ~fieldName, ~operator) => {
-  `SELECT * FROM "${pgSchema}"."${tableName}" WHERE "${fieldName}" ${operator} $1;`
-}
-
-let makeLoadByIdsQuery = (~pgSchema, ~tableName) => {
-  `SELECT * FROM "${pgSchema}"."${tableName}" WHERE id = ANY($1::text[]);`
+// Appends the filter's serialized field values to params (mutated in place)
+// and returns the matching SQL condition referencing them by index.
+// Field names are spliced as quoted identifiers only after the queryFields
+// lookup proves they exist on the table (and they originate from
+// codegen-validated schemas), so the interpolation can't be abused.
+let rec makeFilterCondition = (
+  ~filter: EntityFilter.t,
+  ~table: Table.table,
+  ~params: array<JSON.t>,
+) => {
+  // Filters reference fields by API name, while the SQL references columns
+  // by their possibly renamed db names.
+  let getQueryFieldOrThrow = fieldName =>
+    switch table->Table.queryFields->Dict.get(fieldName) {
+    | Some(queryField) => queryField
+    | None =>
+      throw(
+        Persistence.StorageError({
+          message: `Failed loading "${table.tableName}" from storage. The table doesn't have the field "${fieldName}".`,
+          reason: Table.NonExistingTableField(fieldName),
+        }),
+      )
+    }
+  let serializeParamOrThrow = (~queryField: Table.queryField, ~fieldName, ~fieldValue: unknown, ~isArray) => {
+    let param = try fieldValue->S.reverseConvertToJsonOrThrow(
+      isArray ? queryField.arrayFieldSchema : queryField.fieldSchema,
+    ) catch {
+    | exn =>
+      throw(
+        Persistence.StorageError({
+          message: `Failed loading "${table.tableName}" from storage by field "${fieldName}". Couldn't serialize provided value.`,
+          reason: exn,
+        }),
+      )
+    }
+    params->Array.push(param)->ignore
+    `$${params->Array.length->Int.toString}`
+  }
+  let scalarCondition = (~fieldName, ~fieldValue, ~op) => {
+    let queryField = getQueryFieldOrThrow(fieldName)
+    `"${queryField.pgDbFieldName}" ${op} ${serializeParamOrThrow(
+        ~queryField,
+        ~fieldName,
+        ~fieldValue,
+        ~isArray=false,
+      )}`
+  }
+  switch filter {
+  | Eq({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op="=")
+  | Gt({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op=">")
+  | Lt({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op="<")
+  | In({fieldName, fieldValue}) => {
+      let queryField = getQueryFieldOrThrow(fieldName)
+      `"${queryField.pgDbFieldName}" = ANY(${serializeParamOrThrow(
+          ~queryField,
+          ~fieldName,
+          ~fieldValue=fieldValue->(Utils.magic: array<unknown> => unknown),
+          ~isArray=true,
+        )})`
+    }
+  | And({filters: []}) =>
+    throw(
+      Persistence.StorageError({
+        message: `Failed loading "${table.tableName}" from storage. The "and" filter must contain at least one nested filter.`,
+        reason: Utils.Error.make(`Empty "and" filter`),
+      }),
+    )
+  | And({filters}) =>
+    `(${filters
+      ->Array.map(filter => makeFilterCondition(~filter, ~table, ~params))
+      ->Array.join(" AND ")})`
+  }
 }
 
 let makeDeleteByIdQuery = (~pgSchema, ~tableName) => {
@@ -309,7 +375,7 @@ let makeInsertUnnestSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema, ~is
   let {quotedFieldNames, quotedNonPrimaryFieldNames, arrayFieldTypes} =
     table->Table.toSqlParams(~schema=itemSchema, ~pgSchema)
 
-  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table)
+  let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table)
 
   `INSERT INTO "${pgSchema}"."${table.tableName}" (${quotedFieldNames->Array.joinUnsafe(", ")})
 SELECT * FROM unnest(${arrayFieldTypes
@@ -339,7 +405,7 @@ let makeInsertValuesSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema, ~it
   let {quotedFieldNames, quotedNonPrimaryFieldNames} =
     table->Table.toSqlParams(~schema=itemSchema, ~pgSchema)
 
-  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table)
+  let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table)
   let fieldsCount = quotedFieldNames->Array.length
 
   // Create placeholder variables for the VALUES clause - using $1, $2, etc.
@@ -698,9 +764,9 @@ let makeInsertDeleteUpdatesQuery = (~entityConfig: Internal.entityConfig, ~pgSch
   )
 
   // Get all field names for the INSERT statement
-  let allHistoryFieldNames = entityConfig.table.fields->Belt.Array.keepMap(fieldOrDerived =>
+  let allHistoryFieldNames = entityConfig.table.fields->Array.filterMap(fieldOrDerived =>
     switch fieldOrDerived {
-    | Field(field) => field->Table.getDbFieldName->Some
+    | Field(field) => field->Table.getPgDbFieldName->Some
     | DerivedFrom(_) => None
     }
   )
@@ -708,10 +774,10 @@ let makeInsertDeleteUpdatesQuery = (~entityConfig: Internal.entityConfig, ~pgSch
   allHistoryFieldNames->Array.push(EntityHistory.changeFieldName)->ignore
 
   let allHistoryFieldNamesStr =
-    allHistoryFieldNames->Belt.Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
+    allHistoryFieldNames->Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
 
   // Build the SELECT part: id from unnest, envio_checkpoint_id from unnest, 'DELETE' for action, NULL for all other fields
-  let selectParts = allHistoryFieldNames->Belt.Array.map(fieldName => {
+  let selectParts = allHistoryFieldNames->Array.map(fieldName => {
     switch fieldName {
     | field if field == Table.idFieldName => `u.${Table.idFieldName}`
     | field if field == EntityHistory.checkpointIdFieldName =>
@@ -772,8 +838,8 @@ let makeRawEvent = (
   eventItem: Internal.eventItem,
   ~config: Config.t,
 ): InternalTable.RawEvents.t => {
-  let {event, eventConfig, chain, blockNumber, timestamp: blockTimestamp} = eventItem
-  let {block, transaction, params, logIndex, srcAddress} = event
+  let {event, eventConfig, chain, blockNumber, blockHash, timestamp: blockTimestamp} = eventItem
+  let {block, transaction, params, logIndex, srcAddress} = event->Internal.toGenericEvent
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =
@@ -809,7 +875,7 @@ let makeRawEvent = (
     blockNumber,
     logIndex,
     srcAddress,
-    blockHash: block->config.ecosystem.getId,
+    blockHash,
     blockTimestamp,
     blockFields,
     transactionFields,
@@ -838,7 +904,7 @@ let rec writeBatch = async (
     let specificError = ref(None)
 
     let rawEvents = if config.enableRawEvents {
-      let rows = batch.items->Belt.Array.keepMap(item =>
+      let rows = batch.items->Array.filterMap(item =>
         switch item {
         | Internal.Event(_) => Some(item->Internal.castUnsafeEventItem->makeRawEvent(~config))
         | Internal.Block(_) => None
@@ -869,7 +935,7 @@ let rec writeBatch = async (
       }
     }
 
-    let setEntities = updatedEntities->Belt.Array.map(({entityConfig, changes}) => {
+    let setEntities = updatedEntities->Array.map(({entityConfig, changes}) => {
       let entitiesToSet = []
       let idsToDelete = []
 
@@ -888,10 +954,10 @@ let rec writeBatch = async (
       // history-table batches.
       let latestChangeById = Dict.make()
       let orderedIds = []
-      changes->Belt.Array.forEach(change => {
+      changes->Array.forEach(change => {
         let entityId = change->Change.getEntityId
         if latestChangeById->Utils.Dict.dangerouslyGetNonOption(entityId)->Option.isNone {
-          orderedIds->Belt.Array.push(entityId)
+          orderedIds->Array.push(entityId)
         }
         latestChangeById->Dict.set(entityId, change)
         if shouldSaveHistory {
@@ -900,19 +966,19 @@ let rec writeBatch = async (
           } else {
             switch change {
             | Delete({entityId, checkpointId}) =>
-              batchDeleteEntityIds->Belt.Array.push(entityId)->ignore
-              batchDeleteCheckpointIds->Belt.Array.push(checkpointId)->ignore
-            | Set(_) => batchSetUpdates->Belt.Array.push(change)->ignore
+              batchDeleteEntityIds->Array.push(entityId)->ignore
+              batchDeleteCheckpointIds->Array.push(checkpointId)->ignore
+            | Set(_) => batchSetUpdates->Array.push(change)->ignore
             }
           }
         }
       })
 
       let backfillHistoryIds = Utils.Set.make()
-      orderedIds->Belt.Array.forEach(entityId => {
+      orderedIds->Array.forEach(entityId => {
         switch latestChangeById->Dict.getUnsafe(entityId) {
-        | Set({entity}) => entitiesToSet->Belt.Array.push(entity)
-        | Delete({entityId}) => idsToDelete->Belt.Array.push(entityId)
+        | Set({entity}) => entitiesToSet->Array.push(entity)
+        | Delete({entityId}) => idsToDelete->Array.push(entityId)
         }
 
         // An id needs a history backfill iff none of its changes is the diff.
@@ -943,7 +1009,7 @@ let rec writeBatch = async (
             }
 
             if batchDeleteCheckpointIds->Utils.Array.notEmpty {
-              promises->Belt.Array.push(
+              promises->Array.push(
                 sql
                 ->Postgres.preparedUnsafe(
                   makeInsertDeleteUpdatesQuery(~entityConfig, ~pgSchema),
@@ -986,7 +1052,7 @@ let rec writeBatch = async (
             if shouldRemoveInvalidUtf8 {
               entitiesToSet->removeInvalidUtf8InPlace
             }
-            promises->Belt.Array.push(
+            promises->Array.push(
               sql->setOrThrow(
                 ~items=entitiesToSet,
                 ~table=entityConfig.table,
@@ -996,7 +1062,7 @@ let rec writeBatch = async (
             )
           }
           if idsToDelete->Utils.Array.notEmpty {
-            promises->Belt.Array.push(
+            promises->Array.push(
               sql->deleteByIdsOrThrow(~pgSchema, ~ids=idsToDelete, ~table=entityConfig.table),
             )
           }
@@ -1066,7 +1132,7 @@ let rec writeBatch = async (
                 }),
               ),
             setRawEvents,
-          ]->Belt.Array.concat(setEntities)
+          ]->Array.concat(setEntities)
 
           switch chainMetaData {
           | Some(chainsData) =>
@@ -1079,7 +1145,7 @@ let rec writeBatch = async (
           }
 
           if shouldSaveHistory {
-            setOperations->Belt.Array.push(sql =>
+            setOperations->Array.push(sql =>
               sql->InternalTable.Checkpoints.insert(
                 ~pgSchema,
                 ~checkpointIds=batch.checkpointIds,
@@ -1092,7 +1158,7 @@ let rec writeBatch = async (
           }
 
           await setOperations
-          ->Belt.Array.map(dbFunc => sql->dbFunc)
+          ->Array.map(dbFunc => sql->dbFunc)
           ->Promise.all
           ->Utils.Promise.ignoreValue
 
@@ -1108,7 +1174,7 @@ let rec writeBatch = async (
         // Since effect cache currently doesn't support rollback,
         // we can run it outside of the transaction for simplicity.
         updatedEffectsCache
-        ->Belt.Array.map(({effect, items, shouldInitialize}: Persistence.updatedEffectCache) => {
+        ->Array.map(({effect, items, shouldInitialize}: Persistence.updatedEffectCache) => {
           setEffectCacheOrThrow(~effect, ~items, ~initialize=shouldInitialize)
         })
         ->Promise.all,
@@ -1157,15 +1223,15 @@ let rec writeBatch = async (
 // Returns the most recent entity state for IDs that need to be restored during rollback.
 // For each ID modified after the rollback target, retrieves its latest state at or before the target.
 let makeGetRollbackRestoredEntitiesQuery = (~entityConfig: Internal.entityConfig, ~pgSchema) => {
-  let dataFieldNames = entityConfig.table.fields->Belt.Array.keepMap(fieldOrDerived =>
+  let dataFieldNames = entityConfig.table.fields->Array.filterMap(fieldOrDerived =>
     switch fieldOrDerived {
-    | Field(field) => field->Table.getDbFieldName->Some
+    | Field(field) => field->Table.getPgDbFieldName->Some
     | DerivedFrom(_) => None
     }
   )
 
   let dataFieldsCommaSeparated =
-    dataFieldNames->Belt.Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
+    dataFieldNames->Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
 
   let historyTableName = EntityHistory.historyTableName(
     ~entityName=entityConfig.name,
@@ -1434,80 +1500,26 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     }
   }
 
-  let loadByIdsOrThrow = async (~ids, ~table: Table.table, ~rowsSchema) => {
-    switch await (
-      switch ids {
-      | [_] =>
-        sql->Postgres.preparedUnsafe(
-          makeLoadByIdQuery(~pgSchema, ~tableName=table.tableName),
-          ids->Obj.magic,
-        )
-      | _ =>
-        sql->Postgres.preparedUnsafe(
-          makeLoadByIdsQuery(~pgSchema, ~tableName=table.tableName),
-          [ids]->Obj.magic,
-        )
-      }
-    ) {
-    | exception exn =>
-      throw(
-        Persistence.StorageError({
-          message: `Failed loading "${table.tableName}" from storage by ids`,
-          reason: exn,
-        }),
-      )
-    | rows =>
-      try rows->S.parseOrThrow(rowsSchema) catch {
-      | exn =>
-        throw(
-          Persistence.StorageError({
-            message: `Failed to parse "${table.tableName}" loaded from storage by ids`,
-            reason: exn,
-          }),
-        )
-      }
-    }
-  }
-
-  let loadByFieldOrThrow = async (
-    ~fieldName: string,
-    ~fieldSchema,
-    ~fieldValue,
-    ~operator: Persistence.operator,
-    ~table: Table.table,
-    ~rowsSchema,
-  ) => {
-    let params = try [fieldValue->S.reverseConvertToJsonOrThrow(fieldSchema)]->Obj.magic catch {
-    | exn =>
-      throw(
-        Persistence.StorageError({
-          message: `Failed loading "${table.tableName}" from storage by field "${fieldName}". Couldn't serialize provided value.`,
-          reason: exn,
-        }),
-      )
-    }
+  let loadOrThrow = async (~filter: EntityFilter.t, ~table: Table.table) => {
+    let params = []
+    let condition = makeFilterCondition(~filter, ~table, ~params)
     switch await sql->Postgres.preparedUnsafe(
-      makeLoadByFieldQuery(
-        ~pgSchema,
-        ~tableName=table.tableName,
-        ~fieldName,
-        ~operator=(operator :> string),
-      ),
-      params,
+      makeLoadQuery(~pgSchema, ~tableName=table.tableName, ~condition),
+      params->Obj.magic,
     ) {
     | exception exn =>
       throw(
         Persistence.StorageError({
-          message: `Failed loading "${table.tableName}" from storage by field "${fieldName}"`,
+          message: `Failed loading "${table.tableName}" from storage by condition: ${condition}`,
           reason: exn,
         }),
       )
     | rows =>
-      try rows->S.parseOrThrow(rowsSchema) catch {
+      try rows->S.parseOrThrow(table->Table.pgRowsSchema) catch {
       | exn =>
         throw(
           Persistence.StorageError({
-            message: `Failed to parse "${table.tableName}" loaded from storage by ids`,
+            message: `Failed to parse "${table.tableName}" loaded from storage by condition: ${condition}`,
             reason: exn,
           }),
         )
@@ -1576,7 +1588,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
             Logging.info(
               `Dumping cache: ${cacheTableInfo
                 ->Array.map(({tableName, count}) =>
-                  tableName ++ " (" ++ count->Belt.Int.toString ++ " rows)"
+                  tableName ++ " (" ++ count->Int.toString ++ " rows)"
                 )
                 ->Array.joinUnsafe(", ")}`,
             )
@@ -1620,7 +1632,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         sql,
         ~pgSchema,
       )->Promise.thenResolve(rawInitialStates => {
-        rawInitialStates->Belt.Array.map((rawInitialState): Persistence.initialChainState => {
+        rawInitialStates->Array.map((rawInitialState): Persistence.initialChainState => {
           id: rawInitialState.id,
           startBlock: rawInitialState.startBlock,
           endBlock: rawInitialState.endBlock->Null.toOption,
@@ -1651,10 +1663,10 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       InternalTable.EnvioInfo.read(sql, ~pgSchema),
     ))
 
-    let checkpointId = (checkpointIdResult->Belt.Array.getUnsafe(0))["id"]->BigInt.fromStringOrThrow
+    let checkpointId = (checkpointIdResult->Array.getUnsafe(0))["id"]->BigInt.fromStringOrThrow
 
     // Convert string checkpoint IDs from DB to bigint
-    let reorgCheckpoints = Belt.Array.map(reorgCheckpoints, (raw): Internal.reorgCheckpoint => {
+    let reorgCheckpoints = Array.map(reorgCheckpoints, (raw): Internal.reorgCheckpoint => {
       checkpointId: raw["id"]->BigInt.fromStringOrThrow,
       chainId: raw["chain_id"],
       blockNumber: raw["block_number"],
@@ -1803,8 +1815,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     isInitialized,
     initialize,
     resumeInitialState,
-    loadByFieldOrThrow,
-    loadByIdsOrThrow,
+    loadOrThrow,
     dumpEffectCache,
     reset,
     setChainMeta,
@@ -1883,7 +1894,7 @@ let makeStorageFromEnv = (
               ~pgSchema,
               ~userEntities=config->Config.getPgUserEntities,
               ~responseLimit=Env.Hasura.responseLimit,
-              ~schema=Schema.make(config.allEntities->Belt.Array.map(e => e.table)),
+              ~schema=Schema.make(config.allEntities->Array.map(e => e.table)),
               ~aggregateEntities=Env.Hasura.aggregateEntities,
             )->Promise.catch(err => {
               Logging.errorWithExn(err->Utils.prettifyExn, `Error tracking tables`)->Promise.resolve
@@ -1908,7 +1919,7 @@ let makeStorageFromEnv = (
               ~tableConfigs=tableNames->Array.map(tableName => {
                 Hasura.tableName,
                 description: None,
-                columnDescriptions: dict{},
+                columnConfigs: dict{},
               }),
             )->Promise.catch(err => {
               Logging.errorWithExn(