envio 3.15.0-subgraph → 3.16.0-subgraph

package/src/Storage.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Fs from "fs";
 import * as Env from "./Env.res.mjs";
 import * as Sql from "./db/Sql.res.mjs";
 import * as Path from "path";
@@ -12,16 +11,16 @@ import * as Logger from "./Logger.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as Staging from "./Staging.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
 import * as Frontier from "./db/Frontier.res.mjs";
 import * as Internal from "./Internal.res.mjs";
-import * as PgWriting from "./PgWriting.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as ClickHouse from "./bindings/ClickHouse.res.mjs";
 import * as LoadFilter from "./db/LoadFilter.res.mjs";
+import * as StagedRows from "./StagedRows.res.mjs";
 import * as AddressRows from "./AddressRows.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
@@ -30,21 +29,12 @@ import * as HistoryPolicy from "./HistoryPolicy.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as StorageClient from "./bindings/StorageClient.res.mjs";
-import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
-import * as IndexDefinition from "./db/IndexDefinition.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function formatSeconds(seconds) {
-  return (Math.round(seconds * 100) / 100).toString();
-}
-
-let slowOnLargeDatabaseNotice = "This can take a long time on a large database.";
-
 function storeName(store) {
   if (store === "Postgres") {
     return "postgres";
@@ -55,83 +45,11 @@ function storeName(store) {
 
 let postgresName = "postgres";
 
-function logIndexEvent(logger, pgSchema, event) {
-  switch (event.kind) {
-    case "Invalid" :
-      return Logger.warn(logger, `Ignoring invalid PostgreSQL indexes in schema "` + pgSchema + `". They can't serve queries, so the indexer builds its own alongside them.`, {
-        storage: postgresName,
-        indexes: event.names
-      });
-    case "Planned" :
-      let rebuilt = event.rebuilt;
-      let missing = event.missing;
-      if (Utils.$$Array.notEmpty(rebuilt)) {
-        Logger.warn(logger, `PostgreSQL reports ` + rebuilt.length.toString() + ` of the indexer's own indexes as invalid, so they can't serve queries. Rebuilding them.`, {
-          storage: postgresName,
-          indexes: rebuilt
-        });
-      }
-      if (missing.length !== 0) {
-        return Logger.info(logger, `Creating the ` + missing.length.toString() + ` remaining schema indexes before the indexer reports ready. Writes are paused until they are committed. ` + slowOnLargeDatabaseNotice, {
-          storage: postgresName,
-          indexes: missing
-        });
-      } else {
-        return Logger.info(logger, `All ` + event.declared.toString() + ` schema indexes are already in place. Marking the indexer ready.`, {
-          storage: postgresName
-        });
-      }
-    case "Building" :
-      if (event.purpose === "Query") {
-        return Logger.info(logger, (
-          event.isRebuild ? "Rebuilding unusable index" : "Creating index"
-        ) + ` "` + event.name + `" to serve a getWhere query on "` + event.tableName + `". Writes to the table are paused until it completes. ` + slowOnLargeDatabaseNotice, {
-          storage: postgresName
-        });
-      } else {
-        return Logger.info(logger, (
-          event.isRebuild ? "Rebuilding unusable index" : "Creating missing index"
-        ) + ` "` + event.name + `" the schema promises but the database no longer has. Writes to the table are paused until it completes. ` + slowOnLargeDatabaseNotice, {
-          storage: postgresName
-        });
-      }
-    case "Built" :
-      let tmp;
-      tmp = event.purpose === "Query" ? " Resuming indexing." : "";
-      return Logger.info(logger, `Index "` + event.name + `" is ready after ` + formatSeconds(event.seconds) + `s.` + tmp, {
-        storage: postgresName
-      });
-    case "Failed" :
-      if (event.purpose === "Query") {
-        return Logger.warn(logger, `Failed to create an index on "` + event.tableName + `"(` + event.columns.map(column => `"` + column + `"`).join(", ") + `) for a getWhere query. The query runs without it.`, {
-          storage: postgresName,
-          err: event.error,
-          code: event.code
-        });
-      } else {
-        return Logger.warn(logger, `Failed to restore the schema index "` + event.name + `". Queries relying on it run unindexed until the next restart.`, {
-          storage: postgresName,
-          err: event.error,
-          code: event.code
-        });
-      }
-    case "ResyncFailed" :
-      return Logger.trace(logger, `Could not re-read the index "` + event.name + `" after a failed build. The next attempt reads it again.`, {
-        storage: postgresName,
-        err: event.error,
-        code: event.code
-      });
-    case "Committed" :
-      return Logger.info(logger, `Committed ` + event.count.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(event.seconds) + `s.`, {
-        storage: postgresName
-      });
-  }
-}
-
-function postgresOptions(pgSchemaOpt, isHasuraEnabledOpt, maxConnectionsOpt) {
+function postgresOptions(pgSchemaOpt, isHasuraEnabledOpt, maxConnectionsOpt, isolatedOpt) {
   let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
   let isHasuraEnabled = isHasuraEnabledOpt !== undefined ? isHasuraEnabledOpt : false;
   let maxConnections = maxConnectionsOpt !== undefined ? maxConnectionsOpt : Env.Db.maxConnections;
+  let isolated = isolatedOpt !== undefined ? isolatedOpt : false;
   return {
     host: Env.Db.host,
     port: Env.Db.port,
@@ -142,298 +60,23 @@ function postgresOptions(pgSchemaOpt, isHasuraEnabledOpt, maxConnectionsOpt) {
     maxConnections: maxConnections,
     applicationName: `hyperindex/` + Utils.EnvioPackage.value.version,
     pgSchema: pgSchema,
-    isHasuraEnabled: isHasuraEnabled
+    isHasuraEnabled: isHasuraEnabled,
+    isolated: isolated
   };
 }
 
-function makeClient(logger, chainIdModeOpt, postgres, clickhouse) {
-  let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
+function makeClient(logger, config, postgres, clickhouse) {
   return StorageClient.make({
-    chainIdMode: chainIdMode,
     postgres: postgres,
     clickhouse: clickhouse
-  }, event => logIndexEvent(logger, postgres.pgSchema, event), message => Logger.warn(logger, message, {
-    storage: "clickhouse"
-  }));
-}
-
-function partitionTableName(entityConfig, chainId) {
-  let chainIdStr = ChainId.toString(chainId);
-  return Table.fitPgTableName(entityConfig.table.tableName + `$` + chainIdStr, `$` + entityConfig.index.toString() + `$` + chainIdStr);
-}
-
-function indexTableNames(entityConfig, partitionChainIds) {
-  let match = Table.getChainIdField(entityConfig.table);
-  if (match !== undefined) {
-    if (partitionChainIds !== undefined) {
-      return partitionChainIds.map(chainId => partitionTableName(entityConfig, chainId));
-    } else {
-      return [entityConfig.table.tableName];
-    }
-  } else {
-    return [entityConfig.table.tableName];
-  }
-}
-
-function getSchemaIndexes(entities, partitionChainIds) {
-  let derivedSchema = Schema.make(entities.map(e => e.table));
-  let all = [];
-  entities.forEach(param => {
-    let table = param.table;
-    Table.getSingleIndexes(table).forEach(column => {
-      all.push(IndexDefinition.single(table.tableName, column));
-    });
-    Table.getCompositeIndexes(table).forEach(indexFields => {
-      all.push(IndexDefinition.fromIndexFields(table.tableName, indexFields));
-    });
-  });
-  entities.forEach(param => {
-    Table.getDerivedFromFields(param.table).forEach(derivedFromField => {
-      let column = Utils.unwrapResultExn(Schema.getDerivedFromPgFieldName(derivedSchema, derivedFromField));
-      let isList = Stdlib_Option.mapOr(Stdlib_Option.flatMap(derivedSchema[derivedFromField.derivedFromEntity], table => Table.getFieldByName(table, derivedFromField.derivedFromField)), false, field => {
-        if (field.TAG === "Field") {
-          return field._0.isArray;
-        } else {
-          return false;
-        }
-      });
-      all.push(IndexDefinition.make(derivedFromField.derivedFromEntity, [{
-          name: column,
-          direction: "Asc"
-        }], isList ? "gin" : undefined));
-    });
-  });
-  let seen = new Set();
-  let entityByTableName = {};
-  entities.forEach(entityConfig => {
-    entityByTableName[entityConfig.table.tableName] = entityConfig;
-  });
-  return all.filter(definition => {
-    let identity = IndexDefinition.describe(definition);
-    if (seen.has(identity)) {
-      return false;
-    } else {
-      seen.add(identity);
-      return true;
-    }
-  }).flatMap(definition => indexTableNames(Stdlib_Option.getOrThrow(entityByTableName[definition.tableName], undefined), partitionChainIds).map(tableName => ({
-    tableName: tableName,
-    columns: definition.columns,
-    method: definition.method
-  })));
-}
-
-function pgColumnInput(field) {
-  let match = Table.pgFieldTypeParts(field.fieldType);
-  return {
-    name: Table.getPgDbFieldName(field),
-    fieldType: match[0],
-    isArray: field.isArray,
-    isNullable: field.isNullable,
-    isPrimaryKey: field.isPrimaryKey,
-    defaultValue: field.defaultValue,
-    precision: match[1],
-    scale: match[2],
-    enumName: match[3]
-  };
-}
-
-let rowSchemaCache = new WeakMap();
-
-function getRowSchema(entityConfig) {
-  let cached = rowSchemaCache.get(entityConfig);
-  if (cached !== undefined) {
-    return Primitive_option.valFromOption(cached);
-  }
-  let chainIdField = Table.getChainIdField(entityConfig.table);
-  let schema = chainIdField !== undefined ? S$RescriptSchema.schema(s => {
-      let dict = {};
-      let match = entityConfig.schema.t;
-      let exit = 0;
-      if (typeof match !== "object" || match.TAG !== "object") {
-        exit = 1;
-      } else {
-        match.items.forEach(param => {
-          dict[param.location] = s.m(param.schema);
-        });
-      }
-      if (exit === 1) {
-        Stdlib_JsError.throwWithMessage(`Unexpected non-object schema for entity "` + entityConfig.name + `".`);
-      }
-      dict[chainIdField.fieldName] = s.m(ChainId.schema);
-      return dict;
-    }) : entityConfig.schema;
-  rowSchemaCache.set(entityConfig, schema);
-  return schema;
-}
-
-function register(client, table, itemSchema, postgresOpt, clickhouse, appendOnlyOpt, history) {
-  let postgres = postgresOpt !== undefined ? postgresOpt : true;
-  let appendOnly = appendOnlyOpt !== undefined ? appendOnlyOpt : false;
-  let fields = Table.schemaOrderedFields(table, itemSchema);
-  let chainIdField = Table.getChainIdField(table);
-  let registered = client.registerTable({
-    name: table.tableName,
-    postgres: postgres ? ({
-        columns: Table.getFields(table).map(pgColumnInput),
-        writeColumns: fields.map(Table.getPgDbFieldName),
-        partitionByColumn: Stdlib_Option.map(chainIdField, Table.getPgDbFieldName),
-        appendOnly: appendOnly,
-        historyTable: history,
-        chainIdColumn: history !== undefined ? Stdlib_Option.map(chainIdField, Table.getPgDbFieldName) : undefined
-      }) : undefined,
-    clickhouse: clickhouse
-  });
-  return {
-    handle: registered.handle,
-    home: registered.home,
-    table: table,
-    fields: fields,
-    postgres: Stdlib_Option.map(registered.postgres, param => ({
-      staged: Stdlib_Option.map(param.kinds, kinds => PgWriting.columns(fields, kinds.map(Staging.kindOfOrdinal)))
-    })),
-    clickhouse: Stdlib_Option.map(registered.clickhouse, __x => ClickHouse.makeTable(registered.handle, Stdlib_Option.getOr(history, table.tableName), __x))
-  };
-}
-
-function registerEntity(client, entityConfig) {
-  return register(client, entityConfig.table, getRowSchema(entityConfig), entityConfig.storage.postgres, entityConfig.storage.clickhouse ? ClickHouse.entityTable(entityConfig) : undefined, undefined, EntityHistory.historyTableName(entityConfig.name, entityConfig.index));
-}
-
-function renderDocument(value, isNullable) {
-  if (value == null) {
-    if (value === null && !isNullable) {
-      return "null";
-    } else {
-      return value;
-    }
-  } else {
-    return Sql.stringifyDocument(value);
-  }
-}
-
-let arenaConverters = new WeakMap();
-
-let cellConverters = new WeakMap();
-
-function converterOf(registered, forArena, itemSchema) {
-  let converters = forArena ? arenaConverters : cellConverters;
-  let convert = converters.get(itemSchema);
-  if (convert !== undefined) {
-    return convert;
-  }
-  let documents = Stdlib_Array.filterMapWithIndex(registered.fields, (field, index) => {
-    if (field.fieldType === "Json") {
-      return [
-        index,
-        field
-      ];
-    }
-  });
-  let schema = forArena ? Table.toDbSchema(registered.table, itemSchema) : itemSchema;
-  let convert$1 = S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(schema), param => ({
-    s: columns => {
-      documents.forEach(param => {
-        let field = param[1];
-        let values = columns[param[0]];
-        for (let row = 0, row_finish = values.length; row < row_finish; ++row) {
-          let value = values[row];
-          values[row] = !(value == null) && field.isArray ? value.map(document => renderDocument(document, true)) : renderDocument(value, field.isNullable);
-        }
-      });
-      return columns;
-    }
-  })), "Output", "Input", "Sync", false);
-  converters.set(itemSchema, convert$1);
-  return convert$1;
-}
-
-function refuseNonFinite(values, fields) {
-  fields.forEach((field, index) => {
-    if (field.fieldType !== "Number") {
-      return;
-    }
-    let column = Table.getPgDbFieldName(field);
-    let check = value => {
-      if (value == null) {
-        return;
-      }
-      Staging.finiteOrThrow(value, column);
-    };
-    values[index].forEach(value => {
-      if (!field.isArray) {
-        return check(value);
-      }
-      if (value == null) {
-        return;
-      }
-      value.forEach(check);
-    });
-  });
-}
-
-function stagedFor(staged, store, stage) {
-  let started = Performance.now();
-  let result = stage();
-  let name = storeName(store);
-  staged.seconds[name] = Stdlib_Option.getOr(staged.seconds[name], 0) + Performance.secondsSince(started);
-  return result;
-}
-
-function rowsOrThrow(client, registered, itemSchema, items, staged) {
-  return stagedFor(staged, "Postgres", () => {
-    let rows = items.length;
-    try {
-      let match = registered.postgres;
-      if (match === undefined) {
-        return Stdlib_JsError.throwWithMessage(`Postgres doesn't keep "` + registered.table.tableName + `"`);
-      }
-      let columns = match.staged;
-      if (columns !== undefined) {
-        let values = converterOf(registered, true, itemSchema)(items);
-        let handle = PgWriting.stage(StorageClient.arena(client, "Postgres"), registered.handle, columns, values, rows);
-        staged.handles.push(handle);
-        return {
-          staged: handle,
-          rows: rows
-        };
-      }
-      let values$1 = converterOf(registered, false, itemSchema)(items);
-      refuseNonFinite(values$1, registered.fields);
-      return {
-        cells: Sql.params(values$1.flat(1)),
-        rows: rows
-      };
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
-        throw {
-          RE_EXN_ID: Persistence.StorageError,
-          message: `Failed to convert items for table "` + registered.table.tableName + `"`,
-          reason: exn,
-          Error: new Error()
-        };
-      }
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed to insert items into table "` + registered.table.tableName + `"`,
-        reason: Utils.prettifyExn(exn),
-        Error: new Error()
-      };
-    }
-  });
-}
-
-function renderIds(table, ids) {
-  return Table.encodeIdsToJson(table, ids).map(Sql.render);
+  }, Stdlib_Option.map(config, config => JSON.stringify(config.envioInfo)), logger);
 }
 
 function bounds(param) {
-  let match = Frontier.unnestParams(param.byChain);
+  let byChain = param.byChain;
   return {
-    sequence: param.sequence,
-    chainIds: match[0],
-    checkpointIds: match[1]
+    chainIds: Frontier.chainIds(byChain),
+    checkpointIds: Frontier.chainIds(byChain).map(chainId => Frontier.get(byChain, chainId))
   };
 }
 
@@ -484,18 +127,71 @@ function storageErrorOf(exn) {
   }
 }
 
-let rollbackRowStateSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.object(s => [
-  s.f(Table.idFieldName, Table.getIdSchema(table)),
-  s.f(EntityHistory.changeFieldName, EntityHistory.RowAction.schema)
-]));
-
 let rollbackChainIdSchema = Utils.$$WeakMap.memoize(table => Stdlib_Option.map(Table.getChainIdField(table), field => S$RescriptSchema.object(s => s.f(Table.getPgDbFieldName(field), ChainId.schema))));
 
 let rollbackRemovedIdSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.object(s => s.f(Table.idFieldName, Table.getIdSchema(table))));
 
-function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onInitialize) {
-  let entities = entitiesOpt !== undefined ? entitiesOpt : [];
-  let isolated = isolatedOpt !== undefined ? isolatedOpt : false;
+let changeColumns = [
+  {
+    name: EntityHistory.checkpointIdFieldName,
+    kind: 2,
+    isNullable: false
+  },
+  {
+    name: EntityHistory.changeFieldName,
+    kind: 0,
+    isNullable: false
+  }
+];
+
+function stageOrThrow(arena, columns, rows, fill) {
+  let stage = Staging.begin(arena, rows, columns);
+  try {
+    fill(stage);
+    return Staging.commit(stage);
+  } catch (exn) {
+    Staging.abort(stage);
+    throw exn;
+  }
+}
+
+function stageRowsOrThrow(arena, writers, items) {
+  return stageOrThrow(arena, StagedRows.columnsOf(writers), items.length, stage => {
+    items.forEach((item, row) => {
+      writers.forEach((param, column) => StagedRows.writeField(stage, writers, column, row, item[param.field.name]));
+    });
+  });
+}
+
+function stageChangesOrThrow(arena, writers, changes) {
+  let fields = writers.length;
+  return stageOrThrow(arena, StagedRows.columnsOf(writers).concat(changeColumns), changes.length, stage => {
+    changes.forEach((change, row) => {
+      let entityId = change.entityId;
+      if (change.type === "SET") {
+        let entity = change.entity;
+        writers.forEach((param, column) => {
+          let field = param.field;
+          StagedRows.writeField(stage, writers, column, row, field.name === Table.idFieldName ? entityId : entity[field.name]);
+        });
+      } else {
+        writers.forEach((param, column) => {
+          if (param.field.name === Table.idFieldName) {
+            return StagedRows.writeField(stage, writers, column, row, entityId);
+          } else {
+            return Staging.writeDeletedValue(stage, column, row, undefined);
+          }
+        });
+      }
+      Staging.writeValue(stage, fields, row, change.checkpointId);
+      let tmp;
+      tmp = change.type === "SET" ? 0 : 1;
+      Staging.writeValue(stage, fields + 1 | 0, row, tmp);
+    });
+  });
+}
+
+function make(client, cacheDir, ecosystem, onInitialize) {
   let eagerSchemaIndexes = Env.subgraphMode.contents;
   let keptEffectCaches = Env.subgraphMode.contents ? [
       "envio_subgraph_eth_call",
@@ -506,142 +202,33 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
       "envio_subgraph_arweave"
     ] : undefined;
   let cacheDirPath = cacheDir !== undefined ? Primitive_option.valFromOption(cacheDir) : Path.resolve(".envio", "cache");
-  let registry = {};
-  let registered = (table, register) => {
-    let registered$1 = registry[table.tableName];
-    if (registered$1 !== undefined) {
-      return registered$1;
-    }
-    let registered$2 = register();
-    registry[table.tableName] = registered$2;
-    return registered$2;
-  };
-  let entityTable = entityConfig => registered(entityConfig.table, () => registerEntity(client, entityConfig));
-  let ownTable = (table, itemSchema, appendOnly) => registered(table, () => register(client, table, itemSchema, undefined, undefined, appendOnly, undefined));
-  let rawEventsTable = () => ownTable(InternalTable.RawEvents.table, InternalTable.RawEvents.schema, true);
-  entities.forEach(entityConfig => {
-    entityTable(entityConfig);
+  let layouts = client.layouts();
+  let entityIndexByName = {};
+  layouts.entities.forEach((layout, index) => {
+    entityIndexByName[layout.name] = index;
   });
-  let tableOf = table => {
-    let registered = registry[table.tableName];
-    if (registered !== undefined) {
-      return registered;
-    } else if (Stdlib_Option.isSome(Internal.EffectCache.fromTableName(table.tableName))) {
-      return ownTable(table, Internal.cacheItemSchema, undefined);
-    } else {
-      return Stdlib_JsError.throwWithMessage(`The storage has no table "` + table.tableName + `".`);
-    }
-  };
-  let partitions = (entities, chainIds) => entities.filter(entityConfig => {
-    if (entityConfig.storage.postgres) {
-      return Stdlib_Option.isSome(Table.getChainIdField(entityConfig.table));
-    } else {
-      return false;
-    }
-  }).flatMap(entityConfig => chainIds.map(chainId => ({
-    table: entityTable(entityConfig).handle,
-    chainId: chainId,
-    name: partitionTableName(entityConfig, chainId)
-  })));
+  let entityWriters = layouts.entities.map(layout => StagedRows.writersOf(layout.fields));
+  let rawEventWriters = StagedRows.writersOf(layouts.rawEvents);
+  let effectCacheWriters = StagedRows.writersOf(layouts.effectCache);
   let holding = () => client.holding();
-  let scanCacheDir = async () => {
-    let topEntries;
-    try {
-      topEntries = await Fs.promises.readdir(cacheDirPath);
-    } catch (exn) {
-      topEntries = [];
-    }
-    let result = [];
-    await Promise.all(topEntries.map(async entry => {
-      let entryPath = Path.join(cacheDirPath, entry);
-      let isDir = (await Fs.promises.stat(entryPath)).isDirectory();
-      if (isDir) {
-        let subEntries = await Fs.promises.readdir(entryPath);
-        let tsvs = subEntries.filter(sub => sub.endsWith(".tsv"));
-        let chainId = Internal.EffectCache.parseChainId(entry);
-        if (chainId === undefined) {
-          if (Utils.$$Array.notEmpty(tsvs)) {
-            return Stdlib_JsError.throwWithMessage(`Invalid effect cache directory ".envio/cache/` + entry + `". Chain cache directories must be named by a numeric chain id (e.g. "1"). Found cache files: ` + tsvs.join(", ") + `.`);
-          } else {
-            return;
-          }
-        }
-        let chainId$1 = Primitive_option.valFromOption(chainId);
-        tsvs.forEach(sub => {
-          let effectName = sub.slice(0, -4);
-          let table = Internal.makeCacheTable(effectName, chainId$1);
-          result.push([
-            table,
-            Path.join(entryPath, sub)
-          ]);
-        });
-        return;
-      }
-      if (!entry.endsWith(".tsv")) {
-        return;
-      }
-      let effectName = entry.slice(0, -4);
-      let table = Internal.makeCacheTable(effectName, "crossChain");
-      result.push([
-        table,
-        entryPath
-      ]);
-    }));
-    return result;
-  };
   let restoreEffectCache = async withUpload => {
-    if (withUpload) {
-      let entries = await scanCacheDir();
-      if (entries.length !== 0) {
-        try {
-          await client.uploadEffectCache(entries.map(param => ({
-            table: ownTable(param[0], Internal.cacheItemSchema, undefined).handle,
-            path: param[1]
-          })));
-          Logger.info(logger, "Successfully uploaded cache.", undefined);
-        } catch (raw_exn) {
-          let exn = Primitive_exceptions.internalToException(raw_exn);
-          Logger.errorWithExn(logger, "Failed to upload cache, continuing without it.", exn);
-        }
-      } else {
-        Logger.info(logger, "No saved effect cache to load from .envio/cache.", undefined);
-      }
-    }
     let cache = {};
-    (await client.effectCacheTables()).forEach(param => {
+    (await client.restoreEffectCache(cacheDirPath, withUpload)).forEach(param => {
       let tableName = param.tableName;
-      let match = Internal.EffectCache.fromTableName(tableName);
-      if (match !== undefined) {
-        cache[tableName] = {
-          effectName: match[0],
-          scope: match[1],
-          tableName: tableName,
-          count: param.rows
-        };
-        return;
-      }
+      let chainId = param.chainId;
+      cache[tableName] = {
+        effectName: param.effectName,
+        scope: chainId !== undefined ? Primitive_option.valFromOption(chainId) : "crossChain",
+        tableName: tableName,
+        count: param.rows
+      };
     });
     return cache;
   };
-  let partitionChainIds = chainIds => {
-    if (isolated) {
-      return Primitive_option.some(chainIds);
-    }
-  };
-  let schemaIndexes = (entities, chainIds) => getSchemaIndexes(entities.filter(e => e.storage.postgres), partitionChainIds(chainIds)).map(IndexDefinition.toInput);
-  let initialize = async (chainConfigsOpt, entitiesOpt, enumsOpt, contractMapping, envioInfo) => {
+  let initialize = async (chainConfigsOpt, contractMapping, envioInfo) => {
     let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
-    let entities = entitiesOpt !== undefined ? entitiesOpt : [];
-    let enums = enumsOpt !== undefined ? enumsOpt : [];
     let rowsByChain = chainConfigs.map(chainConfig => ChainState.configStorageRows(chainConfig, ecosystem, contractMapping));
     await client.initialize({
-      sequence: CheckpointSequence.fromEntities(entities),
-      tables: [rawEventsTable().handle].concat(entities.map(entityConfig => entityTable(entityConfig).handle)),
-      partitions: partitions(entities, chainConfigs.map(chainConfig => chainConfig.id)),
-      enums: enums.map(enumConfig => ({
-        name: enumConfig.name,
-        variants: enumConfig.variants
-      })),
       chains: chainConfigs.map(toChainConfig),
       envioInfo: JSON.stringify(envioInfo),
       contractNames: ContractMapping.names(contractMapping),
@@ -649,7 +236,7 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
       keptEffectCaches: keptEffectCaches
     });
     if (eagerSchemaIndexes) {
-      await client.ensureSchemaIndexes(schemaIndexes(entities, chainConfigs.map(chainConfig => chainConfig.id)));
+      await client.ensureSchemaIndexes(chainConfigs.map(chainConfig => chainConfig.id));
     }
     let cache = await restoreEffectCache(true);
     if (onInitialize !== undefined) {
@@ -678,9 +265,11 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
   };
   let loadOrThrow = async (filter, table) => {
     let conditions = LoadFilter.make(filter, table, field => field.pgDbFieldName);
+    let entity = entityIndexByName[table.tableName];
+    let loading = entity !== undefined ? StorageClient.loadWhere(client, entity, conditions) : StorageClient.loadEffectCache(client, table.tableName, conditions);
     let rows;
     try {
-      rows = await StorageClient.loadWhere(client, tableOf(table).handle, conditions);
+      rows = await loading;
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
@@ -720,44 +309,17 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
     }));
     return columns;
   };
-  let queryTableName = (entityConfig, scope) => {
-    if (scope === "crossChain") {
-      return entityConfig.table.tableName;
-    } else {
-      return indexTableNames(entityConfig, partitionChainIds([scope]))[0];
-    }
-  };
   let ensureQueryIndexes = async (entityConfig, scope, filters) => {
-    let building = client.ensureQueryIndexes(entityTable(entityConfig).handle, queryTableName(entityConfig, scope), filterColumns(entityConfig.table, filters));
+    let building = client.ensureQueryIndexes(entityConfig.index, Stdlib_Null.fromOption(Internal.chainScopeChainId(scope)), filterColumns(entityConfig.table, filters));
     if (building === null) {
       return;
     } else {
       return await building;
     }
   };
-  let ensureSchemaIndexes = (entities, chainIds) => client.ensureSchemaIndexes(schemaIndexes(entities, chainIds));
-  let finalizeBackfill = (entities, chainIds, readyAt) => client.finalizeBackfill(schemaIndexes(entities, chainIds), chainIds, readyAt.getTime());
-  let dumpEffectCache = async () => {
-    try {
-      let tables = (await client.effectCacheTables()).filter(param => param.rows > 0);
-      if (Utils.$$Array.notEmpty(tables)) {
-        Logger.info(logger, `Dumping cache: ` + tables.map(param => param.tableName + " (" + param.rows.toString() + " rows)").join(", "), undefined);
-        await client.dumpEffectCache(Stdlib_Array.filterMap(tables, param => {
-          let tableName = param.tableName;
-          return Stdlib_Option.map(Internal.EffectCache.fromTableName(tableName), param => ({
-            tableName: tableName,
-            path: Path.join(cacheDirPath, Internal.EffectCache.toCachePath(param[0], param[1]))
-          }));
-        }));
-        return Logger.info(logger, `Successfully dumped cache to ` + cacheDirPath, undefined);
-      } else {
-        return;
-      }
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      return Logger.errorWithExn(logger, `Failed to dump cache.`, exn);
-    }
-  };
+  let ensureSchemaIndexes = chainIds => client.ensureSchemaIndexes(chainIds);
+  let finalizeBackfill = (chainIds, readyAt) => client.finalizeBackfill(chainIds, readyAt.getTime());
+  let dumpEffectCache = () => client.dumpEffectCache(cacheDirPath);
   let readStoredConfig = async () => {
     let stored = await client.readStoredConfig();
     let configAddresses = StorageClient.read(client, stored.configAddresses);
@@ -795,19 +357,14 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
       contractMapping: ContractMapping.fromStoredNames(match$1)
     };
   };
-  let addChain = (chainConfig, entities, contractMapping) => client.addChain({
+  let addChain = (chainConfig, contractMapping) => client.addChain({
     chain: toChainConfig(chainConfig),
-    partitions: partitions(entities, [chainConfig.id]),
     addresses: addressColumns(ChainState.configStorageRows(chainConfig, ecosystem, contractMapping))
   });
-  let resumeInitialState = async (entities, chainIds, contractMapping) => {
+  let resumeInitialState = async (chainIds, contractMapping) => {
     let match = await Promise.all([
       restoreEffectCache(false),
-      client.resume({
-        sequence: CheckpointSequence.fromEntities(entities),
-        tables: entities.map(entityConfig => entityTable(entityConfig).handle),
-        chainIds: chainIds
-      })
+      client.resume(chainIds)
     ]);
     let resumed = match[1];
     let addressRowsByChainId = AddressRows.group(StorageClient.read(client, resumed.addresses));
@@ -834,10 +391,10 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
     });
     let checkpointFrontier = Frontier.fromEntries(stored.map(param => [
       param[0],
-      BigInt(param[1].checkpointId)
+      param[1].checkpointId
     ]));
     let reorgCheckpoints = resumed.reorgCheckpoints.map(checkpoint => ({
-      id: BigInt(checkpoint.id),
+      id: checkpoint.id,
       chain_id: ChainId.normalizeOrThrow(checkpoint.chainId),
       block_number: checkpoint.blockNumber,
       block_hash: checkpoint.blockHash
@@ -864,15 +421,15 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
   });
   let setChainMeta = chainsData => client.setChainMeta(chainMeta(chainsData)).then(() => (undefined));
   let pruneStaleCheckpoints = safeCheckpoints => client.pruneCheckpoints(bounds(safeCheckpoints));
-  let pruneStaleEntityHistory = (entityConfig, safeCheckpoints) => client.pruneHistory(entityTable(entityConfig).handle, bounds(safeCheckpoints));
-  let getRollbackTargetCheckpoint = async (reorgChainId, lastKnownValidBlockNumber, sequence) => Stdlib_Option.map(Primitive_option.fromNullable(await client.rollbackTargetCheckpoint(reorgChainId, lastKnownValidBlockNumber, sequence)), prim => BigInt(prim));
+  let pruneStaleEntityHistory = (entityConfig, safeCheckpoints) => client.pruneHistory(entityConfig.index, bounds(safeCheckpoints));
+  let getRollbackTargetCheckpoint = async (reorgChainId, lastKnownValidBlockNumber) => Primitive_option.fromNullable(await client.rollbackTargetCheckpoint(reorgChainId, lastKnownValidBlockNumber));
   let getRollbackProgressDiff = async floors => (await client.rollbackProgressDiff(bounds(floors.checkpointBounds))).map(diff => ({
     chain_id: ChainId.normalizeOrThrow(diff.chainId),
     events_processed_diff: diff.eventsProcessed,
     new_progress_block_number: diff.progressBlock
   }));
   let getRollbackData = async (entityConfig, floors) => {
-    let match = await client.rollbackData(entityTable(entityConfig).handle, bounds(floors.checkpointBounds));
+    let match = await client.rollbackData(entityConfig.index, bounds(floors.checkpointBounds));
     let restored = match.restored;
     let removedIdRows;
     try {
@@ -890,29 +447,28 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
         return "crossChain";
       }
     };
-    let removals = removedIdRows.map(row => ({
-      entityId: S$RescriptSchema.parseOrThrow(row, rollbackRemovedIdSchema(entityConfig.table)),
-      scope: scopeOf(row)
-    }));
-    let restoredEntitiesResult = [];
-    rollbackRows.forEach(row => {
-      let match = S$RescriptSchema.parseOrThrow(row, rollbackRowStateSchema(entityConfig.table));
-      if (match[1] === "SET") {
-        restoredEntitiesResult.push(row);
-        return;
-      }
-      removals.push({
-        entityId: match[0],
-        scope: scopeOf(row)
-      });
-    });
     return [
-      removals,
-      S$RescriptSchema.parseOrThrow(restoredEntitiesResult, Table.pgRowsSchema(entityConfig.table))
+      removedIdRows.map(row => ({
+        entityId: S$RescriptSchema.parseOrThrow(row, rollbackRemovedIdSchema(entityConfig.table)),
+        scope: scopeOf(row)
+      })),
+      S$RescriptSchema.parseOrThrow(rollbackRows, Table.pgRowsSchema(entityConfig.table))
     ];
   };
-  let writeBatch = async (batch, rollback, config, allEntities, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, onWrite) => {
-    let match = Frontier.unnestParams(Persistence.writtenFrontier(batch, rollback));
+  let stageRows = (table, writers, items) => stageRowsOrThrow(StorageClient.arena(client, rows => client.beginRows(table, rows)), writers, items);
+  let stageChanges = param => {
+    let entityConfig = param.entityConfig;
+    return stageChangesOrThrow(StorageClient.arena(client, rows => client.beginChanges(entityConfig.index, rows)), entityWriters[entityConfig.index], param.changes);
+  };
+  let changesErrorOf = (entityConfig, exn) => ({
+    RE_EXN_ID: Persistence.StorageError,
+    message: entityConfig.storage.postgres ? `Failed to insert items into table "` + entityConfig.table.tableName + `"` : `Failed to convert items for ClickHouse table "` + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + `"`,
+    reason: Utils.prettifyExn(exn)
+  });
+  let writeBatch = async (batch, rollback, config, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, onWrite) => {
+    let frontier = Persistence.writtenFrontier(batch, rollback);
+    let chainIds = Frontier.chainIds(frontier);
+    let frontierCheckpointIds = chainIds.map(chainId => Frontier.get(frontier, chainId));
     let rawEvents;
     if (config.enableRawEvents) {
       let seenLogCoordinates = new Set();
@@ -931,21 +487,35 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
     } else {
       rawEvents = [];
     }
-    let staged_handles = [];
-    let staged_seconds = {};
-    let staged = {
-      handles: staged_handles,
-      seconds: staged_seconds
+    let handles = [];
+    let staged = handle => {
+      handles.push(handle);
+      return handle;
+    };
+    let stagingStarted = Performance.now();
+    let clickHouseStagingSeconds = {
+      contents: 0
+    };
+    let clickHouseOnlyStagingSeconds = {
+      contents: 0
     };
     let input;
     try {
       let tmp;
       if (Utils.$$Array.notEmpty(rawEvents)) {
-        let table = rawEventsTable();
-        tmp = {
-          table: table.handle,
-          rows: rowsOrThrow(client, table, InternalTable.RawEvents.schema, rawEvents, staged)
-        };
+        let tmp$1;
+        try {
+          tmp$1 = staged(stageRows("RawEvents", rawEventWriters, rawEvents));
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          throw {
+            RE_EXN_ID: Persistence.StorageError,
+            message: `Failed to insert items into table "` + InternalTable.RawEvents.table.tableName + `"`,
+            reason: Utils.prettifyExn(exn),
+            Error: new Error()
+          };
+        }
+        tmp = tmp$1;
       } else {
         tmp = undefined;
       }
@@ -954,7 +524,6 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
           let rolledBackAddresses = param.rolledBackAddresses;
           return {
             bounds: bounds(param.floors.checkpointBounds),
-            tables: allEntities.map(entityConfig => entityTable(entityConfig).handle),
             progress: param.progressedChains.map(progress),
             removedAddresses: {
               chainIds: rolledBackAddresses.map(key => key.chainId),
@@ -963,7 +532,7 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
             },
             diffCheckpoints: param.diffCheckpoints.map(diff => ({
               chainId: diff.chainId,
-              checkpointId: diff.checkpointId.toString(),
+              checkpointId: diff.checkpointId,
               blockNumber: diff.blockNumber
             }))
           };
@@ -976,124 +545,41 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
           totalEventsProcessed: chainAfterBatch.totalEventsProcessed
         })),
         rawEvents: tmp,
-        entities: updatedEntities.map(update => {
-          let shouldSaveHistory = update.shouldSaveHistory;
-          let changes = update.changes;
-          let scope = update.scope;
-          let entityConfig = update.entityConfig;
-          let table = entityTable(entityConfig);
-          let match = Table.getChainIdField(entityConfig.table);
-          let chainIdStamp = match !== undefined && scope !== "crossChain" ? [
-              match,
-              scope
-            ] : undefined;
-          let postgresWrite = () => {
-            let stamped;
-            if (chainIdStamp !== undefined) {
-              let chainId = chainIdStamp[1];
-              let field = chainIdStamp[0];
-              stamped = changes.map(change => {
-                if (change.type === "SET") {
-                  return {
-                    type: "SET",
-                    entityId: change.entityId,
-                    entity: Internal.stampChainId(change.entity, field.fieldName, chainId),
-                    checkpointId: change.checkpointId
-                  };
-                } else {
-                  return change;
-                }
-              });
-            } else {
-              stamped = changes;
-            }
-            let diffCheckpointId = Stdlib_Option.flatMap(rollback, r => CheckpointSequence.findForScope(config.checkpointSequence, r.diffFrontier, scope));
-            let historySets = [];
-            let historySetCheckpointIds = [];
-            let historyDeleteIds = [];
-            let historyDeleteCheckpointIds = [];
-            let idsWithDiff = new Set();
-            let latestChangeById = {};
-            let orderedIds = [];
-            stamped.forEach(change => {
-              let entityId = change.entityId;
-              let entityKey = EntityId.toKey(entityId);
-              if (Stdlib_Option.isNone(latestChangeById[entityKey])) {
-                orderedIds.push(entityId);
-              }
-              latestChangeById[entityKey] = change;
-              if (!shouldSaveHistory) {
-                return;
-              }
-              if (change.checkpointId === diffCheckpointId) {
-                idsWithDiff.add(entityKey);
-                return;
-              }
-              if (change.type === "SET") {
-                historySets.push(change.entity);
-                historySetCheckpointIds.push(change.checkpointId.toString());
-                return;
-              }
-              historyDeleteIds.push(change.entityId);
-              historyDeleteCheckpointIds.push(change.checkpointId.toString());
-            });
-            let sets = [];
-            let deletes = [];
-            let backfill = [];
-            orderedIds.forEach(entityId => {
-              let entityKey = EntityId.toKey(entityId);
-              let match = latestChangeById[entityKey];
-              if (match.type === "SET") {
-                sets.push(match.entity);
-              } else {
-                deletes.push(match.entityId);
-              }
-              if (shouldSaveHistory && !idsWithDiff.has(entityKey)) {
-                backfill.push(entityId);
-                return;
-              }
-            });
-            let rowsOf = entities => {
-              if (Utils.$$Array.notEmpty(entities)) {
-                return rowsOrThrow(client, table, getRowSchema(entityConfig), entities, staged);
-              }
-            };
-            return {
-              sets: rowsOf(sets),
-              deletes: renderIds(entityConfig.table, deletes),
-              history: shouldSaveHistory ? ({
-                  backfill: renderIds(entityConfig.table, backfill),
-                  sets: rowsOf(historySets),
-                  setCheckpointIds: historySetCheckpointIds,
-                  deleteIds: renderIds(entityConfig.table, historyDeleteIds),
-                  deleteCheckpointIds: historyDeleteCheckpointIds
-                }) : undefined
-            };
-          };
-          let match$1 = table.clickhouse;
-          let tmp;
-          if (changes.length !== 0 && match$1 !== undefined) {
-            let handle = stagedFor(staged, "ClickHouse", () => ClickHouse.stageChangesOrThrow(StorageClient.arena(client, "ClickHouse"), match$1, entityConfig, scope, changes));
-            staged_handles.push(handle);
-            tmp = handle;
-          } else {
-            tmp = undefined;
+        changes: Stdlib_Array.filterMap(updatedEntities, update => {
+          let match = update.changes;
+          if (match.length === 0) {
+            return;
+          }
+          let started = Performance.now();
+          let handle;
+          try {
+            handle = staged(stageChanges(update));
+          } catch (raw_exn) {
+            let exn = Primitive_exceptions.internalToException(raw_exn);
+            throw changesErrorOf(update.entityConfig, exn);
+          }
+          let seconds = Performance.secondsSince(started);
+          if (update.entityConfig.storage.clickhouse) {
+            clickHouseStagingSeconds.contents = clickHouseStagingSeconds.contents + seconds;
+          }
+          if (!update.entityConfig.storage.postgres) {
+            clickHouseOnlyStagingSeconds.contents = clickHouseOnlyStagingSeconds.contents + seconds;
           }
           return {
-            table: table.handle,
-            chainId: Stdlib_Option.map(chainIdStamp, param => param[1]),
-            postgres: Stdlib_Option.map(table.postgres, param => postgresWrite()),
-            clickhouse: tmp
+            entity: update.entityConfig.index,
+            chainId: Internal.chainScopeChainId(update.scope),
+            keepsHistory: update.shouldSaveHistory,
+            changes: handle
           };
         }),
         chainMeta: Stdlib_Option.mapOr(chainMetaData, [], chainMeta),
         addresses: addressColumns(registeredAddresses.map(staged => staged.row)),
         frontier: {
-          chainIds: match[0],
-          checkpointIds: match[1]
+          chainIds: chainIds,
+          checkpointIds: frontierCheckpointIds
         },
         checkpoints: {
-          ids: batch.checkpointIds.map(id => id.toString()),
+          ids: batch.checkpointIds,
           chainIds: batch.checkpointChainIds,
           blockNumbers: batch.checkpointBlockNumbers,
           blockHashes: batch.checkpointBlockHashes,
@@ -1101,35 +587,59 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
           keepsHistory: batch.checkpointChainIds.map(chainId => HistoryPolicy.forChain(batch.history, chainId))
         },
         effectCaches: updatedEffectsCache.map(param => {
-          let registered = ownTable(param.table, Internal.cacheItemSchema, undefined);
+          let itemSchema = param.itemSchema;
+          let table = param.table;
+          let tmp;
+          try {
+            tmp = staged(stageRows("EffectCache", effectCacheWriters, param.items.map(item => S$RescriptSchema.reverseConvertOrThrow(item, itemSchema))));
+          } catch (raw_exn) {
+            let exn = Primitive_exceptions.internalToException(raw_exn);
+            if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
+              throw {
+                RE_EXN_ID: Persistence.StorageError,
+                message: `Failed to convert items for table "` + table.tableName + `"`,
+                reason: exn,
+                Error: new Error()
+              };
+            }
+            throw {
+              RE_EXN_ID: Persistence.StorageError,
+              message: `Failed to insert items into table "` + table.tableName + `"`,
+              reason: Utils.prettifyExn(exn),
+              Error: new Error()
+            };
+          }
           return {
-            table: registered.handle,
+            table: table.tableName,
             create: param.shouldInitialize,
-            rows: rowsOrThrow(client, registered, param.itemSchema, param.items, staged)
+            rows: tmp
           };
         })
       };
-    } catch (exn) {
-      client.discardStaged(staged_handles);
-      throw exn;
+    } catch (exn$1) {
+      client.discardStaged(handles);
+      throw exn$1;
     }
+    let postgresStagingSeconds = Performance.secondsSince(stagingStarted) - clickHouseOnlyStagingSeconds.contents;
     let timings;
     try {
       timings = await client.writeBatch(input);
-    } catch (raw_exn) {
-      let exn$1 = Primitive_exceptions.internalToException(raw_exn);
-      client.discardStaged(staged_handles);
-      throw storageErrorOf(exn$1);
+    } catch (raw_exn$1) {
+      let exn$2 = Primitive_exceptions.internalToException(raw_exn$1);
+      client.discardStaged(handles);
+      throw storageErrorOf(exn$2);
     }
     timings.forEach(param => {
-      let name = storeName(param.store);
-      onWrite(name, param.seconds + Stdlib_Option.getOr(staged_seconds[name], 0));
+      let store = param.store;
+      let tmp;
+      tmp = store === "Postgres" ? postgresStagingSeconds : clickHouseStagingSeconds.contents;
+      onWrite(storeName(store), param.seconds + tmp);
     });
   };
   let close = () => client.close();
   return {
     name: postgresName,
-    entityStoreName: entityConfig => storeName(entityTable(entityConfig).home),
+    entityStoreName: entityConfig => Stdlib_Option.mapOr(layouts.entities[entityConfig.index].home, postgresName, storeName),
     holding: holding,
     initialize: initialize,
     readStoredConfig: readStoredConfig,
@@ -1154,13 +664,13 @@ function make(client, logger, entitiesOpt, cacheDir, ecosystem, isolatedOpt, onI
 
 function clientFromEnv(config, logger, pgSchemaOpt, isHasuraEnabled, maxConnections) {
   let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
-  return makeClient(logger, config.chainIdMode, postgresOptions(pgSchema, isHasuraEnabled, maxConnections), config.storage.clickhouse ? ClickHouse.optionsFromEnvOrThrow() : undefined);
+  return makeClient(logger, config, postgresOptions(pgSchema, isHasuraEnabled, maxConnections, config.isolated), config.storage.clickhouse ? ClickHouse.optionsFromEnvOrThrow() : undefined);
 }
 
 function makeStorageFromEnv(config, logger, pgSchemaOpt, isHasuraEnabledOpt, maxConnections, cacheDir) {
   let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
   let isHasuraEnabled = isHasuraEnabledOpt !== undefined ? isHasuraEnabledOpt : Env.Hasura.enabled;
-  return make(clientFromEnv(config, logger, pgSchema, isHasuraEnabled, maxConnections), logger, config.userEntities, cacheDir, config.ecosystem.name, config.isolated, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(logger, Env.Hasura.graphqlEndpoint, {
+  return make(clientFromEnv(config, logger, pgSchema, isHasuraEnabled, maxConnections), cacheDir, config.ecosystem.name, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(logger, Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
     }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(config.userEntities.map(e => e.table))), err => Promise.resolve(Logger.errorWithExn(logger, `Error tracking tables`, err))) : undefined);
@@ -1172,36 +682,24 @@ function makePersistenceFromConfig(config, logger, storageOpt) {
 }
 
 export {
-  formatSeconds,
-  slowOnLargeDatabaseNotice,
   storeName,
   postgresName,
-  logIndexEvent,
   postgresOptions,
   makeClient,
-  partitionTableName,
-  indexTableNames,
-  getSchemaIndexes,
-  pgColumnInput,
-  rowSchemaCache,
-  getRowSchema,
-  registerEntity,
-  arenaConverters,
-  cellConverters,
-  converterOf,
-  stagedFor,
-  renderIds,
   bounds,
   progress,
   addressColumns,
   toChainConfig,
   storageErrorOf,
-  rollbackRowStateSchema,
   rollbackChainIdSchema,
   rollbackRemovedIdSchema,
+  changeColumns,
+  stageOrThrow,
+  stageRowsOrThrow,
+  stageChangesOrThrow,
   make,
   clientFromEnv,
   makeStorageFromEnv,
   makePersistenceFromConfig,
 }
-/* rowSchemaCache Not a pure module */
+/* rollbackChainIdSchema Not a pure module */