envio 3.15.0-subgraph → 3.16.0

package/src/Persistence.res

@@ -117,8 +117,6 @@ type storage = {
   // carries a matching row — storage doesn't interpret it.
   initialize: (
     ~chainConfigs: array<Config.chain>=?,
-    ~entities: array<Internal.entityConfig>=?,
-    ~enums: array<Table.enumConfig<Table.enum>>=?,
     ~contractMapping: ContractMapping.t,
     ~envioInfo: JSON.t,
   ) => promise<initialState>,
@@ -129,16 +127,11 @@ type storage = {
   // Brings an initialized storage a chain it doesn't have yet: its row, its
   // partitions and its config addresses, as `initialize` would have created
   // them. The chains already there are left untouched.
-  addChain: (
-    ~chainConfig: Config.chain,
-    ~entities: array<Internal.entityConfig>,
-    ~contractMapping: ContractMapping.t,
-  ) => promise<unit>,
+  addChain: (~chainConfig: Config.chain, ~contractMapping: ContractMapping.t) => promise<unit>,
   // `chainIds` is what this run drives. An isolated run resumes a subset of
   // the stored chains, and ClickHouse's resume trims past each resumed chain's
   // checkpoint, so chains a sibling process is still writing must stay out.
   resumeInitialState: (
-    ~entities: array<Internal.entityConfig>,
     ~chainIds: array<ChainId.t>,
     ~contractMapping: ContractMapping.t,
   ) => promise<initialState>,
@@ -159,19 +152,12 @@ type storage = {
   // never runs `finalizeBackfill`: an index dropped or invalidated while it was
   // down would otherwise never be rebuilt. Best-effort, and safe to run with
   // indexing live.
-  ensureSchemaIndexes: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-  ) => promise<unit>,
+  ensureSchemaIndexes: (~chainIds: array<ChainId.t>) => promise<unit>,
   // Creates every index the schema promises for the given chains, then stamps
   // `ready_at` on them. Called once those chains finish backfill. The indexes
   // are committed one at a time so a failure part way through doesn't undo the
   // ones already built; `ready_at` is only written once they all verify.
-  finalizeBackfill: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-    ~readyAt: Date.t,
-  ) => promise<unit>,
+  finalizeBackfill: (~chainIds: array<ChainId.t>, ~readyAt: Date.t) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
   reset: unit => promise<unit>,
@@ -190,7 +176,6 @@ type storage = {
   getRollbackTargetCheckpoint: (
     ~reorgChainId: ChainId.t,
     ~lastKnownValidBlockNumber: int,
-    ~sequence: CheckpointSequence.t,
   ) => promise<option<Internal.checkpointId>>,
   // Get rollback progress diff
   getRollbackProgressDiff: (
@@ -214,7 +199,6 @@ type storage = {
     ~batch: Batch.t,
     ~rollback: option<rollback>,
     ~config: Config.t,
-    ~allEntities: array<Internal.entityConfig>,
     ~updatedEffectsCache: array<updatedEffectCache>,
     ~updatedEntities: array<updatedEntity>,
     // Addresses this batch registered, with the checkpoint that covers them.
@@ -339,8 +323,6 @@ let init = {
             throw(Refused(Config.setUpMeanwhileMessage))
           }
           let initialState = await persistence.storage.initialize(
-            ~entities=persistence.allEntities,
-            ~enums=persistence.allEnums,
             ~chainConfigs,
             ~contractMapping,
             ~envioInfo,
@@ -397,13 +379,11 @@ let init = {
               )->Array.getUnsafe(0)
             await persistence.storage.addChain(
               ~chainConfig,
-              ~entities=persistence.allEntities,
               ~contractMapping=stored.contractMapping,
             )
           }
           if resume {
             let initialState = await persistence.storage.resumeInitialState(
-              ~entities=persistence.allEntities,
               ~chainIds=chainConfigs->Array.map(chain => chain.id),
               ~contractMapping=stored.contractMapping,
             )

package/src/Persistence.res.mjs

@@ -94,7 +94,7 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
           Error: new Error()
         };
       }
-      let initialState = await persistence.storage.initialize(chainConfigs$1, persistence.allEntities, persistence.allEnums, contractMapping, envioInfo);
+      let initialState = await persistence.storage.initialize(chainConfigs$1, contractMapping, envioInfo);
       Logger.info(logger, `The indexer storage is ready. Starting indexing!`, undefined);
       persistence.storageStatus = {
         TAG: "Ready",
@@ -136,11 +136,11 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
               chainId: chainConfig.id
             });
             let chainConfig$1 = (await StartBlockResolver.resolveAllOrThrow([chainConfig], logger, lowercaseAddresses, startBlockRetry, sourceTiming))[0];
-            await persistence.storage.addChain(chainConfig$1, persistence.allEntities, stored.contractMapping);
+            await persistence.storage.addChain(chainConfig$1, stored.contractMapping);
           }
         }
         if (resume) {
-          let initialState$1 = await persistence.storage.resumeInitialState(persistence.allEntities, chainConfigs.map(chain => chain.id), stored.contractMapping);
+          let initialState$1 = await persistence.storage.resumeInitialState(chainConfigs.map(chain => chain.id), stored.contractMapping);
           persistence.storageStatus = {
             TAG: "Ready",
             _0: initialState$1

package/src/Rollback.res

@@ -130,7 +130,6 @@ and executeRollback = async (
     switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
       ~reorgChainId=reorgChain,
       ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
-      ~sequence=(state->IndexerState.config).checkpointSequence,
     ) {
     | Some(checkpointId) => checkpointId
     | None => 0n

package/src/Rollback.res.mjs

@@ -42,7 +42,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   Logger.info(logger, "Started rollback on reorg", undefined);
   ChainState.setRollbackTargetBlock(IndexerState.getChainState(state, reorgChain), rollbackTargetBlockNumber);
   await Writing.flush(state);
-  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber, IndexerState.config(state).checkpointSequence);
+  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
   let config = IndexerState.config(state);
   let next = RollbackFloors.make(config.checkpointSequence, ChainMap.keys(config.chainMap), reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber);

package/src/RunScope.res

@@ -22,9 +22,6 @@ type contractRegisterRun = {
   chainLogger: Logger.t,
   ecosystem: Ecosystem.t,
   registrations: array<AddressStore.registration>,
-  // Subgraph mode: the creation round the addresses it adds belong to (see
-  // `AddressStore.registration.creationRound`).
-  creationRound?: int,
 }
 
 // An effect call is shared by the runs that asked for it, so it is told by the

package/src/SafeCheckpointTracking.res

@@ -16,9 +16,7 @@ let make = (
 ) => {
   if maxReorgDepth > 0 && shouldRollbackOnReorg {
     let checkpointIds = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
-    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(
-      chainReorgCheckpoints->Array.length,
-    )
+    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
     chainReorgCheckpoints->Array.forEachWithIndex((checkpoint, idx) => {
       checkpointIds->Array.setUnsafe(idx, checkpoint.checkpointId)
       checkpointBlockNumbers->Array.setUnsafe(idx, checkpoint.blockNumber)
@@ -36,7 +34,9 @@ let make = (
 let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int): option<
   Internal.checkpointId,
 > => {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
+  // The first block reorg detection compares is itself reorgable, so the safe
+  // block is the one below it.
+  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth - 1
 
   switch safeCheckpointTracking.checkpointIds {
   | [] => None

package/src/SafeCheckpointTracking.res.mjs

@@ -20,7 +20,7 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
 }
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  let safeBlockNumber = (sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0) - 1 | 0;
   let match = safeCheckpointTracking.checkpointIds;
   if (match.length === 0) {
     return;

package/src/SimulateItems.res

@@ -638,16 +638,7 @@ let parse = (
       // A simulate item must land on a distinct (block, logIndex): event ordering
       // and the dead-input tracker both key on it. Catch explicit duplicates and
       // explicit-vs-auto-increment collisions here, naming both offending indices.
-      // A call is ordered by its position in its transaction's trace, so two
-      // transactions' calls share an index.
-      let coordinate = switch Internal.callRankOfEventName(eventConfig.name) {
-      | Some(_) =>
-        let transactionIndex = (
-          transaction->(Utils.magic: Internal.eventTransaction => {"transactionIndex": int})
-        )["transactionIndex"]
-        `${blockNumber->Int.toString}:tx${transactionIndex->Int.toString}:${logIndex->Int.toString}`
-      | None => `${blockNumber->Int.toString}:${logIndex->Int.toString}`
-      }
+      let coordinate = `${blockNumber->Int.toString}:${logIndex->Int.toString}`
       switch seenCoordinates->Dict.get(coordinate) {
       | Some(firstIndex) =>
         JsError.throwWithMessage(
@@ -682,38 +673,31 @@ let parse = (
         let onEventRegistration = {...reg, index: onEventRegistrationIndex}
         onEventRegistrations->Array.push(onEventRegistration)->ignore
 
-        let item = Internal.Event({
-          onEventRegistration,
-          chainId,
-          blockNumber,
-          logIndex,
-          // Simulate keeps the transaction inline on the payload, so the store
-          // key is unused; a subgraph's call triggers order by it among logs.
-          transactionIndex: switch config.ecosystem.name {
-          | Evm =>
-            (
-              transaction->(Utils.magic: Internal.eventTransaction => {"transactionIndex": int})
-            )["transactionIndex"]
-          | _ => 0
-          },
-          payload: (
-            {
-              contractName: eventConfig.contractName,
-              eventName: eventConfig.name,
-              params,
-              chainId,
-              srcAddress,
-              logIndex,
-              transaction,
-              block,
-            }: Evm.payload
-          )->Evm.fromPayload,
-        })
-        switch Internal.callRankOfEventName(eventConfig.name) {
-        | Some(rank) => item->Internal.markItemCall(~rank)
-        | None => ()
-        }
-        items->Array.push(item)->ignore
+        items
+        ->Array.push(
+          Internal.Event({
+            onEventRegistration,
+            chainId,
+            blockNumber,
+            logIndex,
+            // Simulate keeps the transaction inline on the payload, so the store
+            // key is unused.
+            transactionIndex: 0,
+            payload: (
+              {
+                contractName: eventConfig.contractName,
+                eventName: eventConfig.name,
+                params,
+                chainId,
+                srcAddress,
+                logIndex,
+                transaction,
+                block,
+              }: Evm.payload
+            )->Evm.fromPayload,
+          }),
+        )
+        ->ignore
       })
     }
   })

package/src/SimulateItems.res.mjs

@@ -460,14 +460,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
           break;
       }
       currentBlock.contents = blockNumber$1;
-      let match$12 = Internal.callRankOfEventName(eventConfig$1.name);
-      let coordinate;
-      if (match$12 !== undefined) {
-        let transactionIndex$1 = transaction$1.transactionIndex;
-        coordinate = blockNumber$1.toString() + `:tx` + transactionIndex$1.toString() + `:` + logIndex.toString();
-      } else {
-        coordinate = blockNumber$1.toString() + `:` + logIndex.toString();
-      }
+      let coordinate = blockNumber$1.toString() + `:` + logIndex.toString();
       let firstIndex = seenCoordinates[coordinate];
       if (firstIndex !== undefined) {
         Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + ChainId.toString(chainId) + ` both resolve to block ` + blockNumber$1.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
@@ -476,9 +469,9 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
       }
       let liveRegistrations$1 = liveRegistrationsFor(config, chainId, eventConfig$1);
       if (Utils.$$Array.isEmpty(liveRegistrations$1)) {
-        let match$13 = ChainMap.values(config.chainMap).length;
+        let match$12 = ChainMap.values(config.chainMap).length;
         Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + eventName + `" on contract "` + contractName + `"` + (
-          match$13 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
+          match$12 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
         ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
       }
       liveRegistrations$1.forEach(reg => {
@@ -486,41 +479,24 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         let newrecord = {...reg};
         newrecord.index = onEventRegistrationIndex;
         onEventRegistrations.push(newrecord);
-        let match = config.ecosystem.name;
-        let tmp;
-        switch (match) {
-          case "evm" :
-            tmp = transaction$1.transactionIndex;
-            break;
-          case "fuel" :
-          case "svm" :
-            tmp = 0;
-            break;
-        }
-        let item_6 = {
-          contractName: eventConfig$1.contractName,
-          eventName: eventConfig$1.name,
-          params: params,
-          chainId: chainId,
-          srcAddress: srcAddress,
-          logIndex: logIndex,
-          transaction: Primitive_option.some(transaction$1),
-          block: Primitive_option.some(block$2)
-        };
-        let item = {
+        items.push({
           kind: 0,
           onEventRegistration: newrecord,
           chainId: chainId,
           blockNumber: blockNumber$1,
           logIndex: logIndex,
-          transactionIndex: tmp,
-          payload: item_6
-        };
-        let rank = Internal.callRankOfEventName(eventConfig$1.name);
-        if (rank !== undefined) {
-          Internal.markItemCall(item, rank);
-        }
-        items.push(item);
+          transactionIndex: 0,
+          payload: {
+            contractName: eventConfig$1.contractName,
+            eventName: eventConfig$1.name,
+            params: params,
+            chainId: chainId,
+            srcAddress: srcAddress,
+            logIndex: logIndex,
+            transaction: Primitive_option.some(transaction$1),
+            block: Primitive_option.some(block$2)
+          }
+        });
       });
       return;
     }

package/src/StagedRows.res

@@ -0,0 +1,106 @@
+// Values as the addon declares each staged field has to arrive, compiled once
+// per layout and written into a stage.
+
+@send external getTime: unknown => float = "getTime"
+@send external toFixed: unknown => string = "toFixed"
+@val @scope("Array") external isArray: unknown => bool = "isArray"
+
+// A list element as its JSON: the encoding a scalar of its type would take,
+// except that a boolean stays one and bytes become their values.
+%%private(
+  let elementOf = (encoding: Staging.encoding, ~column): (unknown => unknown) =>
+    switch encoding {
+    | Number =>
+      value =>
+        value->Staging.toNumber->Staging.finiteOrThrow(~column)->(Utils.magic: float => unknown)
+    | Date => value => value->getTime->(Utils.magic: float => unknown)
+    | Digits => value => value->Staging.stringOf->(Utils.magic: string => unknown)
+    | Decimal => value => value->toFixed->(Utils.magic: string => unknown)
+    | Document => value => value->Sql.canonicalDocument->(Utils.magic: string => unknown)
+    | Bytes =>
+      value =>
+        value
+        ->(Utils.magic: unknown => Array.arrayLike<int>)
+        ->Array.fromArrayLike
+        ->(Utils.magic: array<int> => unknown)
+    | Bool | Text | List => value => value
+    }
+)
+
+%%private(
+  let rec mapList = (value: unknown, element: unknown => unknown): unknown =>
+    if value->isArray {
+      value
+      ->(Utils.magic: unknown => array<unknown>)
+      ->Array.map(item => item->mapList(element))
+      ->(Utils.magic: array<unknown> => unknown)
+    } else if value === %raw(`undefined`) || value === %raw(`null`) {
+      %raw(`null`)
+    } else {
+      element(value)
+    }
+)
+
+// What a present value becomes before it is written to its slot.
+%%private(
+  let encoderOf = ({name, encoding, element}: Staging.stagedField): (unknown => unknown) =>
+    switch encoding {
+    | Bool =>
+      value => (value->(Utils.magic: unknown => bool) ? 1. : 0.)->(Utils.magic: float => unknown)
+    | Date => value => value->getTime->(Utils.magic: float => unknown)
+    | Decimal => value => value->toFixed->(Utils.magic: string => unknown)
+    | Document => value => value->Sql.canonicalDocument->(Utils.magic: string => unknown)
+    | List =>
+      let encode = elementOf(element, ~column=name)
+      // A document can be a list itself, so a list of them is one level deep.
+      let mapList = switch element {
+      | Document =>
+        (value, encode) =>
+          value
+          ->(Utils.magic: unknown => array<unknown>)
+          ->Array.map(item => item->Staging.isAbsent ? %raw(`null`) : encode(item))
+          ->(Utils.magic: array<unknown> => unknown)
+      | _ => mapList
+      }
+      value =>
+        value
+        ->mapList(encode)
+        ->(Utils.magic: unknown => JSON.t)
+        ->JSON.stringify
+        ->Utils.replaceLoneSurrogateEscapes
+        ->(Utils.magic: string => unknown)
+    | Number | Text | Digits | Bytes => value => value
+    }
+)
+
+// A layout's fields compiled once: the slot each takes and how a value of it
+// is written there.
+type writer = {field: Staging.stagedField, encode: unknown => unknown}
+
+let writersOf = (fields: array<Staging.stagedField>) =>
+  fields->Array.map(field => {field, encode: encoderOf(field)})
+
+let columnsOf = (writers: array<writer>): array<Staging.column> =>
+  writers->Array.map(({field}) => {
+    Staging.name: field.name,
+    kind: field.encoding->Staging.kindOf,
+    isNullable: field.isNullable,
+  })
+
+// JSON `null` is a document of its own, which a column that can't be NULL
+// stores as one. Left out, the value is no document and is refused like any
+// other.
+let writeField = (stage, ~writers: array<writer>, ~column, ~row, value: unknown) => {
+  let {field, encode} = writers->Array.getUnsafe(column)
+  if value->Staging.isAbsent {
+    stage->Staging.writeValue(
+      ~column,
+      ~row,
+      field.encoding === Staging.Document && !field.isNullable && value === %raw(`null`)
+        ? "null"->(Utils.magic: string => unknown)
+        : value,
+    )
+  } else {
+    stage->Staging.writeValue(~column, ~row, encode(value))
+  }
+}

package/src/StagedRows.res.mjs

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sql from "./db/Sql.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Staging from "./Staging.res.mjs";
+
+function elementOf(encoding, column) {
+  switch (encoding) {
+    case "Number" :
+      return value => Staging.finiteOrThrow(Number(value), column);
+    case "Date" :
+      return value => value.getTime();
+    case "Digits" :
+      return value => String(value);
+    case "Decimal" :
+      return value => value.toFixed();
+    case "Document" :
+      return Sql.canonicalDocument;
+    case "Bytes" :
+      return value => Array.from(value);
+    default:
+      return value => value;
+  }
+}
+
+function mapList(value, element) {
+  if (Array.isArray(value)) {
+    return value.map(item => mapList(item, element));
+  } else if (value === undefined || value === null) {
+    return null;
+  } else {
+    return element(value);
+  }
+}
+
+function encoderOf(param) {
+  let element = param.element;
+  switch (param.encoding) {
+    case "Bool" :
+      return value => {
+        if (value) {
+          return 1;
+        } else {
+          return 0;
+        }
+      };
+    case "Date" :
+      return value => value.getTime();
+    case "Decimal" :
+      return value => value.toFixed();
+    case "Document" :
+      return Sql.canonicalDocument;
+    case "List" :
+      let encode = elementOf(element, param.name);
+      let mapList$1;
+      mapList$1 = element === "Document" ? (value, encode) => value.map(item => {
+          if (Staging.isAbsent(item)) {
+            return null;
+          } else {
+            return encode(item);
+          }
+        }) : mapList;
+      return value => Utils.replaceLoneSurrogateEscapes(JSON.stringify(mapList$1(value, encode)));
+    default:
+      return value => value;
+  }
+}
+
+function writersOf(fields) {
+  return fields.map(field => ({
+    field: field,
+    encode: encoderOf(field)
+  }));
+}
+
+function columnsOf(writers) {
+  return writers.map(param => {
+    let field = param.field;
+    return {
+      name: field.name,
+      kind: Staging.kindOf(field.encoding),
+      isNullable: field.isNullable
+    };
+  });
+}
+
+function writeField(stage, writers, column, row, value) {
+  let match = writers[column];
+  let field = match.field;
+  if (Staging.isAbsent(value)) {
+    return Staging.writeValue(stage, column, row, field.encoding === "Document" && !field.isNullable && value === null ? "null" : value);
+  } else {
+    return Staging.writeValue(stage, column, row, match.encode(value));
+  }
+}
+
+export {
+  writersOf,
+  columnsOf,
+  writeField,
+}
+/* Sql Not a pure module */

package/src/Staging.res

@@ -10,16 +10,6 @@ type kind =
   | @as(3) Text
   | @as(4) Bytes
 
-let kindOfOrdinal = ordinal =>
-  switch ordinal {
-  | 0 => F64
-  | 1 => U64
-  | 2 => I64
-  | 3 => Text
-  | 4 => Bytes
-  | unknown => JsError.throwWithMessage(`Unknown staged column kind ${unknown->Int.toString}`)
-  }
-
 // The replacer closes over nothing but the column's name, so it is built once
 // with the column rather than once per column per batch.
 type column = {name: string, kind: kind, isNullable: bool, replacer?: JSON.replacer}
@@ -28,7 +18,7 @@ type begun = {handle: int, buffers: array<ArrayBuffer.t>}
 
 // What the addon exposes, so this module stays free of the storage's own API.
 type arena = {
-  beginStage: (~table: int, ~rows: int) => begun,
+  beginStage: (~rows: int) => begun,
   growStage: (~handle: int, ~column: int, ~needed: int, ~stale: ArrayBuffer.t) => ArrayBuffer.t,
   commitStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
   abortStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
@@ -79,8 +69,8 @@ type t = {
   builders: array<builder>,
 }
 
-let begin = (arena, ~table, ~rows, ~columns: array<column>) => {
-  let {handle, buffers} = arena.beginStage(~table, ~rows)
+let begin = (arena, ~rows, ~columns: array<column>) => {
+  let {handle, buffers} = arena.beginStage(~rows)
   let slot = ref(0)
   let take = () => {
     let buffer = buffers->Array.getUnsafe(slot.contents)
@@ -275,7 +265,7 @@ let toText = (value: unknown, ~replacer=?) =>
     }
 )
 
-%%private(let isAbsent = (value: unknown) => value === %raw(`undefined`) || value === %raw(`null`))
+let isAbsent = (value: unknown) => value === %raw(`undefined`) || value === %raw(`null`)
 
 // Writes one value of a row the handler set. `undefined`/`null` marks the row's
 // null bit, which a column that accepts NULL stores as such — and which one that
@@ -317,3 +307,31 @@ let commit = stage => {
 }
 
 let abort = stage => stage.arena.abortStage(~handle=stage.handle, ~buffers=stage.buffers)
+
+// How a staged value has to arrive, as the addon declares it for every field:
+// `storage::schema::Encoding`.
+type encoding =
+  | Number
+  | Bool
+  | Date
+  | Text
+  | Digits
+  | Decimal
+  | Document
+  | Bytes
+  | List
+
+type stagedField = {
+  name: string,
+  encoding: encoding,
+  // What a list's elements are encoded as; the field's own for a scalar.
+  element: encoding,
+  isNullable: bool,
+}
+
+let kindOf = (encoding: encoding) =>
+  switch encoding {
+  | Number | Bool | Date => F64
+  | Text | Digits | Decimal | Document | List => Text
+  | Bytes => Bytes
+  }