envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/PgStorage.res.mjs

@@ -2,58 +2,53 @@
 
 import * as Fs from "fs";
 import * as Env from "./Env.res.mjs";
+import * as Sink from "./Sink.res.mjs";
 import * as Path from "path";
-import * as $$Array from "rescript/lib/es6/array.js";
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as $$BigInt from "./bindings/BigInt.res.mjs";
 import * as Config from "./Config.res.mjs";
+import * as Hasura from "./Hasura.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Schema from "./db/Schema.res.mjs";
-import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as Logging from "./Logging.res.mjs";
-import * as $$Promise from "./bindings/Promise.res.mjs";
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as Persistence from "./Persistence.res.mjs";
+import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Child_process from "child_process";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+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 Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var getCacheRowCountFnName = "get_cache_row_count";
+let getCacheRowCountFnName = "get_cache_row_count";
 
 function makeClient() {
   return Postgres({
-              host: Env.Db.host,
-              port: Env.Db.port,
-              database: Env.Db.database,
-              username: Env.Db.user,
-              password: Env.Db.password,
-              ssl: Env.Db.ssl,
-              max: Env.Db.maxConnections,
-              onnotice: Caml_obj.equal(Env.userLogLevel, "warn") || Caml_obj.equal(Env.userLogLevel, "error") ? undefined : (function (_str) {
-                    
-                  }),
-              transform: {
-                undefined: null
-              }
-            });
+    host: Env.Db.host,
+    port: Env.Db.port,
+    database: Env.Db.database,
+    username: Env.Db.user,
+    password: Env.Db.password,
+    ssl: Env.Db.ssl,
+    max: Env.Db.maxConnections,
+    onnotice: Primitive_object.equal(Env.userLogLevel, "warn") || Primitive_object.equal(Env.userLogLevel, "error") ? undefined : _str => {},
+    transform: {
+      undefined: null
+    }
+  });
 }
 
 function makeCreateIndexQuery(tableName, indexFields, pgSchema) {
-  var indexName = tableName + "_" + indexFields.join("_");
-  var index = Belt_Array.map(indexFields, (function (idx) {
-            return "\"" + idx + "\"";
-          })).join(", ");
-  return "CREATE INDEX IF NOT EXISTS \"" + indexName + "\" ON \"" + pgSchema + "\".\"" + tableName + "\"(" + index + ");";
+  let indexName = tableName + "_" + indexFields.join("_");
+  let index = Belt_Array.map(indexFields, idx => `"` + idx + `"`).join(", ");
+  return `CREATE INDEX IF NOT EXISTS "` + indexName + `" ON "` + pgSchema + `"."` + tableName + `"(` + index + `);`;
 }
 
 function directionToSql(direction) {
@@ -73,104 +68,94 @@ function directionToIndexName(direction) {
 }
 
 function makeCreateCompositeIndexQuery(tableName, indexFields, pgSchema) {
-  var indexName = tableName + "_" + indexFields.map(function (f) {
-          return f.fieldName + directionToIndexName(f.direction);
-        }).join("_");
-  var index = Belt_Array.map(indexFields, (function (f) {
-            return "\"" + f.fieldName + "\"" + directionToSql(f.direction);
-          })).join(", ");
-  return "CREATE INDEX IF NOT EXISTS \"" + indexName + "\" ON \"" + pgSchema + "\".\"" + tableName + "\"(" + index + ");";
+  let indexName = tableName + "_" + indexFields.map(f => f.fieldName + directionToIndexName(f.direction)).join("_");
+  let index = Belt_Array.map(indexFields, f => `"` + f.fieldName + `"` + directionToSql(f.direction)).join(", ");
+  return `CREATE INDEX IF NOT EXISTS "` + indexName + `" ON "` + pgSchema + `"."` + tableName + `"(` + index + `);`;
 }
 
 function makeCreateTableIndicesQuery(table, pgSchema) {
-  var tableName = table.tableName;
-  var createIndex = function (indexField) {
-    return makeCreateIndexQuery(tableName, [indexField], pgSchema);
-  };
-  var createCompositeIndex = function (indexFields) {
-    return makeCreateCompositeIndexQuery(tableName, indexFields, pgSchema);
-  };
-  var singleIndices = Table.getSingleIndices(table);
-  var compositeIndices = Table.getCompositeIndices(table);
-  return Belt_Array.map(singleIndices, createIndex).join("\n") + Belt_Array.map(compositeIndices, createCompositeIndex).join("\n");
+  let tableName = table.tableName;
+  let createIndex = indexField => makeCreateIndexQuery(tableName, [indexField], pgSchema);
+  let createCompositeIndex = indexFields => makeCreateCompositeIndexQuery(tableName, indexFields, pgSchema);
+  let singleIndices = Table.getSingleIndices(table);
+  let compositeIndices = Table.getCompositeIndices(table);
+  return singleIndices.map(createIndex).join("\n") + compositeIndices.map(createCompositeIndex).join("\n");
 }
 
 function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText) {
-  var fieldsMapped = Belt_Array.map(Table.getFields(table), (function (field) {
-            var defaultValue = field.defaultValue;
-            var isNullable = field.isNullable;
-            var fieldName = Table.getDbFieldName(field);
-            return "\"" + fieldName + "\" " + Table.getPgFieldType(field.fieldType, pgSchema, field.isArray, isNumericArrayAsText, isNullable) + (
-                    defaultValue !== undefined ? " DEFAULT " + defaultValue : (
-                        isNullable ? "" : " NOT NULL"
-                      )
-                  );
-          })).join(", ");
-  var primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
-  var primaryKey = Belt_Array.map(primaryKeyFieldNames, (function (field) {
-            return "\"" + field + "\"";
-          })).join(", ");
-  return "CREATE TABLE IF NOT EXISTS \"" + pgSchema + "\".\"" + table.tableName + "\"(" + fieldsMapped + (
-          primaryKeyFieldNames.length !== 0 ? ", PRIMARY KEY(" + primaryKey + ")" : ""
-        ) + ");";
+  let fieldsMapped = Table.getFields(table).map(field => {
+    let defaultValue = field.defaultValue;
+    let isNullable = field.isNullable;
+    let fieldName = Table.getDbFieldName(field);
+    return `"` + fieldName + `" ` + Table.getPgFieldType(field.fieldType, pgSchema, field.isArray, isNumericArrayAsText, isNullable) + (
+      defaultValue !== undefined ? ` DEFAULT ` + defaultValue : (
+          isNullable ? `` : ` NOT NULL`
+        )
+    );
+  }).join(", ");
+  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  let primaryKey = primaryKeyFieldNames.map(field => `"` + field + `"`).join(", ");
+  return `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + table.tableName + `"(` + fieldsMapped + (
+    primaryKeyFieldNames.length !== 0 ? `, PRIMARY KEY(` + primaryKey + `)` : ""
+  ) + `);`;
 }
 
-var entityHistoryCache = new WeakMap();
+let entityHistoryCache = new WeakMap();
 
 function getEntityHistory(entityConfig) {
-  var cache = entityHistoryCache.get(entityConfig);
+  let cache = entityHistoryCache.get(entityConfig);
   if (cache !== undefined) {
     return cache;
   }
-  var dataFields = Belt_Array.keepMap(entityConfig.table.fields, (function (field) {
-          if (field.TAG !== "Field") {
-            return ;
-          }
-          var field$1 = field._0;
-          var match = field$1.fieldName;
-          if (match === "id") {
-            return {
-                    TAG: "Field",
-                    _0: {
-                      fieldName: "id",
-                      fieldType: field$1.fieldType,
-                      fieldSchema: field$1.fieldSchema,
-                      isArray: field$1.isArray,
-                      isNullable: field$1.isNullable,
-                      isPrimaryKey: true,
-                      isIndex: field$1.isIndex,
-                      linkedEntity: field$1.linkedEntity,
-                      defaultValue: field$1.defaultValue
-                    }
-                  };
-          } else {
-            return {
-                    TAG: "Field",
-                    _0: {
-                      fieldName: field$1.fieldName,
-                      fieldType: field$1.fieldType,
-                      fieldSchema: field$1.fieldSchema,
-                      isArray: field$1.isArray,
-                      isNullable: true,
-                      isPrimaryKey: field$1.isPrimaryKey,
-                      isIndex: false,
-                      linkedEntity: field$1.linkedEntity,
-                      defaultValue: field$1.defaultValue
-                    }
-                  };
-          }
-        }));
-  var actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined);
-  var checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined);
-  var entityTableName = entityConfig.table.tableName;
-  var historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
-  var table = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
-            checkpointIdField,
-            actionField
-          ]));
-  var setChangeSchema = EntityHistory.makeSetUpdateSchema(entityConfig.schema);
-  var cache_setChangeSchemaRows = S$RescriptSchema.array(setChangeSchema);
-  var cache$1 = {
+  let dataFields = Belt_Array.keepMap(entityConfig.table.fields, field => {
+    if (field.TAG !== "Field") {
+      return;
+    }
+    let field$1 = field._0;
+    let match = field$1.fieldName;
+    if (match === "id") {
+      return {
+        TAG: "Field",
+        _0: {
+          fieldName: "id",
+          fieldType: field$1.fieldType,
+          fieldSchema: field$1.fieldSchema,
+          isArray: field$1.isArray,
+          isNullable: field$1.isNullable,
+          isPrimaryKey: true,
+          isIndex: field$1.isIndex,
+          linkedEntity: field$1.linkedEntity,
+          defaultValue: field$1.defaultValue
+        }
+      };
+    } else {
+      return {
+        TAG: "Field",
+        _0: {
+          fieldName: field$1.fieldName,
+          fieldType: field$1.fieldType,
+          fieldSchema: field$1.fieldSchema,
+          isArray: field$1.isArray,
+          isNullable: true,
+          isPrimaryKey: field$1.isPrimaryKey,
+          isIndex: false,
+          linkedEntity: field$1.linkedEntity,
+          defaultValue: field$1.defaultValue
+        }
+      };
+    }
+  });
+  let actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined);
+  let checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined);
+  let entityTableName = entityConfig.table.tableName;
+  let historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
+  let table = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
+    checkpointIdField,
+    actionField
+  ]));
+  let setChangeSchema = EntityHistory.makeSetUpdateSchema(entityConfig.schema);
+  let cache_setChangeSchemaRows = S$RescriptSchema.array(setChangeSchema);
+  let cache$1 = {
     table: table,
     setChangeSchema: setChangeSchema,
     setChangeSchemaRows: cache_setChangeSchemaRows
@@ -180,166 +165,161 @@ function getEntityHistory(entityConfig) {
 }
 
 function makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt) {
-  var chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
-  var entities = entitiesOpt !== undefined ? entitiesOpt : [];
-  var enums = enumsOpt !== undefined ? enumsOpt : [];
-  var isEmptyPgSchema = isEmptyPgSchemaOpt !== undefined ? isEmptyPgSchemaOpt : false;
-  var generalTables = [
+  let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
+  let entities = entitiesOpt !== undefined ? entitiesOpt : [];
+  let enums = enumsOpt !== undefined ? enumsOpt : [];
+  let isEmptyPgSchema = isEmptyPgSchemaOpt !== undefined ? isEmptyPgSchemaOpt : false;
+  let generalTables = [
     InternalTable.Chains.table,
     InternalTable.PersistedState.table,
     InternalTable.Checkpoints.table,
     InternalTable.RawEvents.table
   ];
-  var allTables = $$Array.copy(generalTables);
-  var allEntityTables = [];
-  entities.forEach(function (entityConfig) {
-        allEntityTables.push(entityConfig.table);
-        allTables.push(entityConfig.table);
-        allTables.push(getEntityHistory(entityConfig).table);
-      });
-  var derivedSchema = Schema.make(allEntityTables);
-  var query = {
+  let allTables = generalTables.slice();
+  let allEntityTables = [];
+  entities.forEach(entityConfig => {
+    allEntityTables.push(entityConfig.table);
+    allTables.push(entityConfig.table);
+    allTables.push(getEntityHistory(entityConfig).table);
+  });
+  let derivedSchema = Schema.make(allEntityTables);
+  let query = {
     contents: (
-      isEmptyPgSchema && pgSchema === "public" ? "CREATE SCHEMA IF NOT EXISTS \"" + pgSchema + "\";\n" : "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;\nCREATE SCHEMA \"" + pgSchema + "\";\n"
-    ) + ("GRANT ALL ON SCHEMA \"" + pgSchema + "\" TO \"" + pgUser + "\";\nGRANT ALL ON SCHEMA \"" + pgSchema + "\" TO public;")
+      isEmptyPgSchema && pgSchema === "public" ? `CREATE SCHEMA IF NOT EXISTS "` + pgSchema + `";\n` : `DROP SCHEMA IF EXISTS "` + pgSchema + `" CASCADE;
+CREATE SCHEMA "` + pgSchema + `";\n`
+    ) + (`GRANT ALL ON SCHEMA "` + pgSchema + `" TO "` + pgUser + `";
+GRANT ALL ON SCHEMA "` + pgSchema + `" TO public;`)
   };
-  enums.forEach(function (enumConfig) {
-        var enumCreateQuery = "CREATE TYPE \"" + pgSchema + "\"." + enumConfig.name + " AS ENUM(" + enumConfig.variants.map(function (v) {
-                return "'" + v + "'";
-              }).join(", ") + ");";
-        query.contents = query.contents + "\n" + enumCreateQuery;
-      });
-  allTables.forEach(function (table) {
-        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema, isHasuraEnabled);
-      });
-  allTables.forEach(function (table) {
-        var indices = makeCreateTableIndicesQuery(table, pgSchema);
-        if (indices !== "") {
-          query.contents = query.contents + "\n" + indices;
-          return ;
-        }
-        
-      });
-  entities.forEach(function (entity) {
-        Table.getDerivedFromFields(entity.table).forEach(function (derivedFromField) {
-              var indexField = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(derivedSchema, derivedFromField));
-              query.contents = query.contents + "\n" + makeCreateIndexQuery(derivedFromField.derivedFromEntity, [indexField], pgSchema);
-            });
-      });
+  enums.forEach(enumConfig => {
+    let enumCreateQuery = `CREATE TYPE "` + pgSchema + `".` + enumConfig.name + ` AS ENUM(` + enumConfig.variants.map(v => `'` + v + `'`).join(", ") + `);`;
+    query.contents = query.contents + "\n" + enumCreateQuery;
+  });
+  allTables.forEach(table => {
+    query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema, isHasuraEnabled);
+  });
+  allTables.forEach(table => {
+    let indices = makeCreateTableIndicesQuery(table, pgSchema);
+    if (indices !== "") {
+      query.contents = query.contents + "\n" + indices;
+      return;
+    }
+  });
+  entities.forEach(entity => {
+    Table.getDerivedFromFields(entity.table).forEach(derivedFromField => {
+      let indexField = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(derivedSchema, derivedFromField));
+      query.contents = query.contents + "\n" + makeCreateIndexQuery(derivedFromField.derivedFromEntity, [indexField], pgSchema);
+    });
+  });
   query.contents = query.contents + "\n" + InternalTable.Views.makeMetaViewQuery(pgSchema);
   query.contents = query.contents + "\n" + InternalTable.Views.makeChainMetadataViewQuery(pgSchema);
-  var initialChainsValuesQuery = InternalTable.Chains.makeInitialValuesQuery(pgSchema, chainConfigs);
+  let initialChainsValuesQuery = InternalTable.Chains.makeInitialValuesQuery(pgSchema, chainConfigs);
   if (initialChainsValuesQuery !== undefined) {
     query.contents = query.contents + "\n" + initialChainsValuesQuery;
   }
   return [
-          query.contents,
-          "CREATE OR REPLACE FUNCTION " + getCacheRowCountFnName + "(table_name text) \nRETURNS integer AS $$\nDECLARE\n  result integer;\nBEGIN\n  EXECUTE format('SELECT COUNT(*) FROM \"" + pgSchema + "\".%I', table_name) INTO result;\n  RETURN result;\nEND;\n$$ LANGUAGE plpgsql;"
-        ];
+    query.contents,
+    `CREATE OR REPLACE FUNCTION ` + getCacheRowCountFnName + `(table_name text) 
+RETURNS integer AS $$
+DECLARE
+  result integer;
+BEGIN
+  EXECUTE format('SELECT COUNT(*) FROM "` + pgSchema + `".%I', table_name) INTO result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql;`
+  ];
 }
 
 function makeLoadByIdQuery(pgSchema, tableName) {
-  return "SELECT * FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE id = $1 LIMIT 1;";
+  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE id = $1 LIMIT 1;`;
 }
 
 function makeLoadByFieldQuery(pgSchema, tableName, fieldName, operator) {
-  return "SELECT * FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE \"" + fieldName + "\" " + operator + " $1;";
+  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE "` + fieldName + `" ` + operator + ` $1;`;
 }
 
 function makeLoadByIdsQuery(pgSchema, tableName) {
-  return "SELECT * FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE id = ANY($1::text[]);";
+  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE id = ANY($1::text[]);`;
 }
 
 function makeDeleteByIdQuery(pgSchema, tableName) {
-  return "DELETE FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE id = $1;";
+  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = $1;`;
 }
 
 function makeDeleteByIdsQuery(pgSchema, tableName) {
-  return "DELETE FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE id = ANY($1::text[]);";
+  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = ANY($1::text[]);`;
 }
 
 function makeLoadAllQuery(pgSchema, tableName) {
-  return "SELECT * FROM \"" + pgSchema + "\".\"" + tableName + "\";";
+  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `";`;
 }
 
 function makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
-  var quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
-  var primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
-  return "INSERT INTO \"" + pgSchema + "\".\"" + table.tableName + "\" (" + match.quotedFieldNames.join(", ") + ")\nSELECT * FROM unnest(" + match.arrayFieldTypes.map(function (arrayFieldType, idx) {
-                return "$" + (idx + 1 | 0).toString() + "::" + arrayFieldType;
-              }).join(",") + ")" + (
-          isRawEvents || primaryKeyFieldNames.length === 0 ? "" : "ON CONFLICT(" + primaryKeyFieldNames.map(function (fieldName) {
-                    return "\"" + fieldName + "\"";
-                  }).join(",") + ") DO " + (
-              Utils.$$Array.isEmpty(quotedNonPrimaryFieldNames) ? "NOTHING" : "UPDATE SET " + quotedNonPrimaryFieldNames.map(function (fieldName) {
-                        return fieldName + " = EXCLUDED." + fieldName;
-                      }).join(",")
-            )
-        ) + ";";
+  let match = Table.toSqlParams(table, itemSchema, pgSchema);
+  let quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
+  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  return `INSERT INTO "` + pgSchema + `"."` + table.tableName + `" (` + match.quotedFieldNames.join(", ") + `)
+SELECT * FROM unnest(` + match.arrayFieldTypes.map((arrayFieldType, idx) => `$` + (idx + 1 | 0).toString() + `::` + arrayFieldType).join(",") + `)` + (
+    isRawEvents || primaryKeyFieldNames.length === 0 ? `` : `ON CONFLICT(` + primaryKeyFieldNames.map(fieldName => `"` + fieldName + `"`).join(",") + `) DO ` + (
+        Utils.$$Array.isEmpty(quotedNonPrimaryFieldNames) ? `NOTHING` : `UPDATE SET ` + quotedNonPrimaryFieldNames.map(fieldName => fieldName + ` = EXCLUDED.` + fieldName).join(",")
+      )
+  ) + ";";
 }
 
 function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
-  var quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
-  var quotedFieldNames = match.quotedFieldNames;
-  var primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
-  var fieldsCount = quotedFieldNames.length;
-  var placeholders = "";
-  for(var idx = 1; idx <= itemsCount; ++idx){
+  let match = Table.toSqlParams(table, itemSchema, pgSchema);
+  let quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
+  let quotedFieldNames = match.quotedFieldNames;
+  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  let fieldsCount = quotedFieldNames.length;
+  let placeholders = "";
+  for (let idx = 1; idx <= itemsCount; ++idx) {
     if (idx > 1) {
       placeholders = placeholders + ",";
     }
     placeholders = placeholders + "(";
-    for(var fieldIdx = 0; fieldIdx < fieldsCount; ++fieldIdx){
+    for (let fieldIdx = 0; fieldIdx < fieldsCount; ++fieldIdx) {
       if (fieldIdx > 0) {
         placeholders = placeholders + ",";
       }
-      placeholders = placeholders + ("$" + (Math.imul(fieldIdx, itemsCount) + idx | 0).toString());
+      placeholders = placeholders + (`$` + ((fieldIdx * itemsCount | 0) + idx | 0).toString());
     }
     placeholders = placeholders + ")";
   }
-  return "INSERT INTO \"" + pgSchema + "\".\"" + table.tableName + "\" (" + quotedFieldNames.join(", ") + ")\nVALUES" + placeholders + (
-          primaryKeyFieldNames.length !== 0 ? "ON CONFLICT(" + primaryKeyFieldNames.map(function (fieldName) {
-                    return "\"" + fieldName + "\"";
-                  }).join(",") + ") DO " + (
-              Utils.$$Array.isEmpty(quotedNonPrimaryFieldNames) ? "NOTHING" : "UPDATE SET " + quotedNonPrimaryFieldNames.map(function (fieldName) {
-                        return fieldName + " = EXCLUDED." + fieldName;
-                      }).join(",")
-            ) : ""
-        ) + ";";
+  return `INSERT INTO "` + pgSchema + `"."` + table.tableName + `" (` + quotedFieldNames.join(", ") + `)
+VALUES` + placeholders + (
+    primaryKeyFieldNames.length !== 0 ? `ON CONFLICT(` + primaryKeyFieldNames.map(fieldName => `"` + fieldName + `"`).join(",") + `) DO ` + (
+        Utils.$$Array.isEmpty(quotedNonPrimaryFieldNames) ? `NOTHING` : `UPDATE SET ` + quotedNonPrimaryFieldNames.map(fieldName => fieldName + ` = EXCLUDED.` + fieldName).join(",")
+      ) : ``
+  ) + ";";
 }
 
 function makeTableBatchSetQuery(pgSchema, table, itemSchema) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
-  var isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
-  var isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
+  let match = Table.toSqlParams(table, itemSchema, pgSchema);
+  let isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
+  let isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
   if ((isRawEvents || !match.hasArrayField) && !isHistoryUpdate) {
     return {
-            query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
-            convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.unnest(match.dbSchema), "Output", "Input", "Sync", false),
-            isInsertValues: false
-          };
+      query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
+      convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.unnest(match.dbSchema), "Output", "Input", "Sync", false),
+      isInsertValues: false
+    };
   } else {
     return {
-            query: makeInsertValuesSetQuery(pgSchema, table, itemSchema, 500),
-            convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), (function (param) {
-                        return {
-                                s: (function (prim) {
-                                    return prim.flat(1);
-                                  })
-                              };
-                      })), "Output", "Input", "Sync", false),
-            isInsertValues: true
-          };
+      query: makeInsertValuesSetQuery(pgSchema, table, itemSchema, 500),
+      convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), param => ({
+        s: prim => prim.flat(1)
+      })), "Output", "Input", "Sync", false),
+      isInsertValues: true
+    };
   }
 }
 
 function chunkArray(arr, chunkSize) {
-  var chunks = [];
-  var i = 0;
-  while(i < arr.length) {
-    var chunk = arr.slice(i, i + chunkSize | 0);
+  let chunks = [];
+  let i = 0;
+  while (i < arr.length) {
+    let chunk = arr.slice(i, i + chunkSize | 0);
     chunks.push(chunk);
     i = i + chunkSize | 0;
   };
@@ -347,35 +327,30 @@ function chunkArray(arr, chunkSize) {
 }
 
 function removeInvalidUtf8InPlace(entities) {
-  entities.forEach(function (item) {
-        Utils.Dict.forEachWithKey(item, (function (value, key) {
-                if (typeof value === "string") {
-                  item[key] = value.replaceAll("\x00", "");
-                  return ;
-                }
-                
-              }));
-      });
+  entities.forEach(item => Utils.Dict.forEachWithKey(item, (value, key) => {
+    if (typeof value === "string") {
+      item[key] = value.replaceAll("\x00", "");
+      return;
+    }
+  }));
 }
 
-var pgErrorMessageSchema = S$RescriptSchema.object(function (s) {
-      return s.f("message", S$RescriptSchema.string);
-    });
+let pgErrorMessageSchema = S$RescriptSchema.object(s => s.f("message", S$RescriptSchema.string));
 
-var PgEncodingError = /* @__PURE__ */Caml_exceptions.create("PgStorage.PgEncodingError");
+let PgEncodingError = /* @__PURE__ */Primitive_exceptions.create("PgStorage.PgEncodingError");
 
-var setQueryCache = new WeakMap();
+let setQueryCache = new WeakMap();
 
 async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
   if (items.length === 0) {
-    return ;
+    return;
   }
-  var cached = setQueryCache.get(table);
-  var data;
+  let cached = setQueryCache.get(table);
+  let data;
   if (cached !== undefined) {
-    data = Caml_option.valFromOption(cached);
+    data = Primitive_option.valFromOption(cached);
   } else {
-    var newQuery = makeTableBatchSetQuery(pgSchema, table, itemSchema);
+    let newQuery = makeTableBatchSetQuery(pgSchema, table, itemSchema);
     setQueryCache.set(table, newQuery);
     data = newQuery;
   }
@@ -383,53 +358,57 @@ async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
     if (!data.isInsertValues) {
       return await sql.unsafe(data.query, data.convertOrThrow(items), {prepare: true});
     }
-    var chunks = chunkArray(items, 500);
-    var responses = [];
-    chunks.forEach(function (chunk) {
-          var chunkSize = chunk.length;
-          var isFullChunk = chunkSize === 500;
-          var params = data.convertOrThrow(chunk);
-          var response = isFullChunk ? sql.unsafe(data.query, params, {prepare: true}) : sql.unsafe(makeInsertValuesSetQuery(pgSchema, table, itemSchema, chunkSize), params);
-          responses.push(response);
-        });
+    let chunks = chunkArray(items, 500);
+    let responses = [];
+    chunks.forEach(chunk => {
+      let chunkSize = chunk.length;
+      let isFullChunk = chunkSize === 500;
+      let params = data.convertOrThrow(chunk);
+      let response = isFullChunk ? sql.unsafe(data.query, params, {prepare: true}) : sql.unsafe(makeInsertValuesSetQuery(pgSchema, table, itemSchema, chunkSize), params);
+      responses.push(response);
+    });
     await Promise.all(responses);
-    return ;
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return;
+  } 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()
-          };
+        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()
-        };
+      RE_EXN_ID: Persistence.StorageError,
+      message: `Failed to insert items into table "` + table.tableName + `"`,
+      reason: Utils.prettifyExn(exn),
+      Error: new Error()
+    };
   }
 }
 
 function makeSchemaTableNamesQuery(pgSchema) {
-  return "SELECT table_name FROM information_schema.tables WHERE table_schema = '" + pgSchema + "';";
+  return `SELECT table_name FROM information_schema.tables WHERE table_schema = '` + pgSchema + `';`;
 }
 
-var cacheTablePrefixLength = Internal.cacheTablePrefix.length;
+let cacheTablePrefixLength = Internal.cacheTablePrefix.length;
 
 function makeSchemaCacheTableInfoQuery(pgSchema) {
-  return "SELECT \n    t.table_name,\n    " + getCacheRowCountFnName + "(t.table_name) as count\n   FROM information_schema.tables t\n   WHERE t.table_schema = '" + pgSchema + "' \n   AND t.table_name LIKE '" + Internal.cacheTablePrefix + "%';";
+  return `SELECT 
+    t.table_name,
+    ` + getCacheRowCountFnName + `(t.table_name) as count
+   FROM information_schema.tables t
+   WHERE t.table_schema = '` + pgSchema + `' 
+   AND t.table_name LIKE '` + Internal.cacheTablePrefix + `%';`;
 }
 
-var psqlExecState = {
+let psqlExecState = {
   contents: "Unknown"
 };
 
 async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName) {
-  var promise = psqlExecState.contents;
+  let promise = psqlExecState.contents;
   if (typeof promise === "object") {
     if (promise.TAG === "Pending") {
       return await promise._0;
@@ -437,36 +416,36 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containe
       return promise._0;
     }
   }
-  var promise$1 = new Promise((function (resolve, _reject) {
-          var binary = "psql";
-          Child_process.exec(binary + " --version", (function (error, param, param$1) {
-                  if (error === null) {
-                    return resolve({
-                                TAG: "Ok",
-                                _0: binary + " -h " + pgHost + " -p " + pgPort.toString() + " -U " + pgUser + " -d " + pgDatabase
-                              });
-                  }
-                  var binary$1 = "docker exec -i -u " + pgUser + " " + containerName + " psql";
-                  Child_process.exec(binary$1 + " --version", (function (error, param, param$1) {
-                          if (error === null) {
-                            return resolve({
-                                        TAG: "Ok",
-                                        _0: binary$1 + " -h " + pgHost + " -p " + (5432).toString() + " -U " + pgUser + " -d " + pgDatabase
-                                      });
-                          } else {
-                            return resolve({
-                                        TAG: "Error",
-                                        _0: "Please check if \"psql\" binary is installed or Docker container \"" + containerName + "\" is running."
-                                      });
-                          }
-                        }));
-                }));
-        }));
+  let promise$1 = new Promise((resolve, _reject) => {
+    let binary = "psql";
+    Child_process.exec(binary + ` --version`, (error, param, param$1) => {
+      if (error === null) {
+        return resolve({
+          TAG: "Ok",
+          _0: binary + ` -h ` + pgHost + ` -p ` + pgPort.toString() + ` -U ` + pgUser + ` -d ` + pgDatabase
+        });
+      }
+      let binary$1 = `docker exec -i -u ` + pgUser + ` ` + containerName + ` psql`;
+      Child_process.exec(binary$1 + ` --version`, (error, param, param$1) => {
+        if (error === null) {
+          return resolve({
+            TAG: "Ok",
+            _0: binary$1 + ` -h ` + pgHost + ` -p ` + (5432).toString() + ` -U ` + pgUser + ` -d ` + pgDatabase
+          });
+        } else {
+          return resolve({
+            TAG: "Error",
+            _0: `Please check if "psql" binary is installed or Docker container "` + containerName + `" is running.`
+          });
+        }
+      });
+    });
+  });
   psqlExecState.contents = {
     TAG: "Pending",
     _0: promise$1
   };
-  var result = await promise$1;
+  let result = await promise$1;
   psqlExecState.contents = {
     TAG: "Resolved",
     _0: result
@@ -479,46 +458,44 @@ async function deleteByIdsOrThrow(sql, pgSchema, ids, table) {
     await (
       ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName), ids, {prepare: true})
     );
-    return ;
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
-          RE_EXN_ID: Persistence.StorageError,
-          message: "Failed deleting \"" + table.tableName + "\" from storage by ids",
-          reason: exn,
-          Error: new Error()
-        };
+      RE_EXN_ID: Persistence.StorageError,
+      message: `Failed deleting "` + table.tableName + `" from storage by ids`,
+      reason: exn,
+      Error: new Error()
+    };
   }
 }
 
 function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema) {
-  var historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  var allHistoryFieldNames = Belt_Array.keepMap(entityConfig.table.fields, (function (fieldOrDerived) {
-          if (fieldOrDerived.TAG === "Field") {
-            return Table.getDbFieldName(fieldOrDerived._0);
-          }
-          
-        }));
+  let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  let allHistoryFieldNames = Belt_Array.keepMap(entityConfig.table.fields, fieldOrDerived => {
+    if (fieldOrDerived.TAG === "Field") {
+      return Table.getDbFieldName(fieldOrDerived._0);
+    }
+  });
   allHistoryFieldNames.push(EntityHistory.checkpointIdFieldName);
   allHistoryFieldNames.push(EntityHistory.changeFieldName);
-  var allHistoryFieldNamesStr = Belt_Array.map(allHistoryFieldNames, (function (name) {
-            return "\"" + name + "\"";
-          })).join(", ");
-  var selectParts = Belt_Array.map(allHistoryFieldNames, (function (fieldName) {
-          if (fieldName === Table.idFieldName) {
-            return "u." + Table.idFieldName;
-          } else if (fieldName === EntityHistory.checkpointIdFieldName) {
-            return "u." + EntityHistory.checkpointIdFieldName;
-          } else if (fieldName === EntityHistory.changeFieldName) {
-            return "'" + "DELETE" + "'";
-          } else {
-            return "NULL";
-          }
-        }));
-  var selectPartsStr = selectParts.join(", ");
-  var checkpointIdPgType = Table.getPgFieldType(EntityHistory.checkpointIdFieldType, pgSchema, false, false, false);
-  return "INSERT INTO \"" + pgSchema + "\".\"" + historyTableName + "\" (" + allHistoryFieldNamesStr + ")\nSELECT " + selectPartsStr + "\nFROM UNNEST($1::text[], $2::" + checkpointIdPgType + "[]) AS u(" + Table.idFieldName + ", " + EntityHistory.checkpointIdFieldName + ")";
+  let allHistoryFieldNamesStr = Belt_Array.map(allHistoryFieldNames, name => `"` + name + `"`).join(", ");
+  let selectParts = Belt_Array.map(allHistoryFieldNames, fieldName => {
+    if (fieldName === Table.idFieldName) {
+      return `u.` + Table.idFieldName;
+    } else if (fieldName === EntityHistory.checkpointIdFieldName) {
+      return `u.` + EntityHistory.checkpointIdFieldName;
+    } else if (fieldName === EntityHistory.changeFieldName) {
+      return `'` + "DELETE" + `'`;
+    } else {
+      return "NULL";
+    }
+  });
+  let selectPartsStr = selectParts.join(", ");
+  let checkpointIdPgType = Table.getPgFieldType(EntityHistory.checkpointIdFieldType, pgSchema, false, false, false);
+  return `INSERT INTO "` + pgSchema + `"."` + historyTableName + `" (` + allHistoryFieldNamesStr + `)
+SELECT ` + selectPartsStr + `
+FROM UNNEST($1::text[], $2::` + checkpointIdPgType + `[]) AS u(` + Table.idFieldName + `, ` + EntityHistory.checkpointIdFieldName + `)`;
 }
 
 function executeSet(sql, items, dbFunction) {
@@ -531,274 +508,257 @@ function executeSet(sql, items, dbFunction) {
 
 async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
   try {
-    var shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
-    var specificError = {
+    let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
+    let specificError = {
       contents: undefined
     };
-    var setRawEvents = function (__x) {
-      return executeSet(__x, rawEvents, (function (sql, items) {
-                    return setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema);
-                  }));
-    };
-    var setEntities = Belt_Array.map(updatedEntities, (function (param) {
-            var updates = param.updates;
-            var entityConfig = param.entityConfig;
-            var entitiesToSet = [];
-            var idsToDelete = [];
-            updates.forEach(function (row) {
-                  var match = row.latestChange;
-                  if (match.type === "SET") {
-                    entitiesToSet.push(match.entity);
-                    return ;
-                  }
-                  idsToDelete.push(match.entityId);
-                });
-            var shouldRemoveInvalidUtf8 = escapeTables !== undefined && Caml_option.valFromOption(escapeTables).has(entityConfig.table) ? true : false;
-            return async function (sql) {
-              try {
-                var promises = [];
-                if (shouldSaveHistory) {
-                  var backfillHistoryIds = new Set();
-                  var batchSetUpdates = [];
-                  var batchDeleteCheckpointIds = [];
-                  var batchDeleteEntityIds = [];
-                  updates.forEach(function (update) {
-                        var containsRollbackDiffChange = update.containsRollbackDiffChange;
-                        update.history.forEach(function (change) {
-                              if (!containsRollbackDiffChange) {
-                                backfillHistoryIds.add(change.entityId);
-                              }
-                              if (change.type === "SET") {
-                                batchSetUpdates.push(change);
-                                return ;
-                              }
-                              batchDeleteEntityIds.push(change.entityId);
-                              batchDeleteCheckpointIds.push(change.checkpointId);
-                            });
-                      });
-                  if (backfillHistoryIds.size !== 0) {
-                    await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.name, entityConfig.index, Array.from(backfillHistoryIds));
-                  }
-                  if (Utils.$$Array.notEmpty(batchDeleteCheckpointIds)) {
-                    promises.push(sql.unsafe(makeInsertDeleteUpdatesQuery(entityConfig, pgSchema), [
-                              batchDeleteEntityIds,
-                              $$BigInt.arrayToStringArray(batchDeleteCheckpointIds)
-                            ], {prepare: true}));
-                  }
-                  if (Utils.$$Array.notEmpty(batchSetUpdates)) {
-                    if (shouldRemoveInvalidUtf8) {
-                      var entities = batchSetUpdates.map(function (batchSetUpdate) {
-                            if (batchSetUpdate.type === "SET") {
-                              return batchSetUpdate.entity;
-                            } else {
-                              return Js_exn.raiseError("Expected Set action");
-                            }
-                          });
-                      removeInvalidUtf8InPlace(entities);
-                    }
-                    var entityHistory = getEntityHistory(entityConfig);
-                    promises.push(setOrThrow(sql, batchSetUpdates, entityHistory.table, entityHistory.setChangeSchema, pgSchema));
-                  }
-                  
-                }
-                if (Utils.$$Array.notEmpty(entitiesToSet)) {
-                  if (shouldRemoveInvalidUtf8) {
-                    removeInvalidUtf8InPlace(entitiesToSet);
-                  }
-                  promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, entityConfig.schema, pgSchema));
+    let setRawEvents = __x => executeSet(__x, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema));
+    let setEntities = Belt_Array.map(updatedEntities, param => {
+      let updates = param.updates;
+      let entityConfig = param.entityConfig;
+      let entitiesToSet = [];
+      let idsToDelete = [];
+      updates.forEach(row => {
+        let match = row.latestChange;
+        if (match.type === "SET") {
+          entitiesToSet.push(match.entity);
+          return;
+        }
+        idsToDelete.push(match.entityId);
+      });
+      let shouldRemoveInvalidUtf8 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables).has(entityConfig.table) : false;
+      return async sql => {
+        try {
+          let promises = [];
+          if (shouldSaveHistory) {
+            let backfillHistoryIds = new Set();
+            let batchSetUpdates = [];
+            let batchDeleteCheckpointIds = [];
+            let batchDeleteEntityIds = [];
+            updates.forEach(update => {
+              let containsRollbackDiffChange = update.containsRollbackDiffChange;
+              update.history.forEach(change => {
+                if (!containsRollbackDiffChange) {
+                  backfillHistoryIds.add(change.entityId);
                 }
-                if (Utils.$$Array.notEmpty(idsToDelete)) {
-                  promises.push(deleteByIdsOrThrow(sql, pgSchema, idsToDelete, entityConfig.table));
+                if (change.type === "SET") {
+                  batchSetUpdates.push(change);
+                  return;
                 }
-                await Promise.all(promises);
-                return ;
-              }
-              catch (raw_exn){
-                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                var normalizedExn = Caml_js_exceptions.internalToOCamlException(exn.RE_EXN_ID === "JsError" || exn.RE_EXN_ID !== Persistence.StorageError ? exn : exn.reason);
-                if (normalizedExn.RE_EXN_ID === "JsError") {
-                  var val;
-                  try {
-                    val = S$RescriptSchema.parseOrThrow(normalizedExn._1, pgErrorMessageSchema);
-                  }
-                  catch (exn$1){
-                    return ;
-                  }
-                  switch (val) {
-                    case "current transaction is aborted, commands ignored until end of transaction block" :
-                        return ;
-                    case "invalid byte sequence for encoding \"UTF8\": 0x00" :
-                        specificError.contents = {
-                          RE_EXN_ID: PgEncodingError,
-                          table: entityConfig.table
-                        };
-                        return ;
-                    default:
-                      specificError.contents = Utils.prettifyExn(exn);
-                      return ;
-                  }
-                } else {
-                  if (normalizedExn.RE_EXN_ID !== S$RescriptSchema.Raised) {
-                    return ;
+                batchDeleteEntityIds.push(change.entityId);
+                batchDeleteCheckpointIds.push(change.checkpointId);
+              });
+            });
+            if (backfillHistoryIds.size !== 0) {
+              await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.name, entityConfig.index, Array.from(backfillHistoryIds));
+            }
+            if (Utils.$$Array.notEmpty(batchDeleteCheckpointIds)) {
+              promises.push(sql.unsafe(makeInsertDeleteUpdatesQuery(entityConfig, pgSchema), [
+                batchDeleteEntityIds,
+                Utils.$$BigInt.arrayToStringArray(batchDeleteCheckpointIds)
+              ], {prepare: true}));
+            }
+            if (Utils.$$Array.notEmpty(batchSetUpdates)) {
+              if (shouldRemoveInvalidUtf8) {
+                removeInvalidUtf8InPlace(batchSetUpdates.map(batchSetUpdate => {
+                  if (batchSetUpdate.type === "SET") {
+                    return batchSetUpdate.entity;
+                  } else {
+                    return Stdlib_JsError.throwWithMessage("Expected Set action");
                   }
-                  throw normalizedExn;
-                }
+                }));
               }
-            };
-          }));
-    var rollbackTables = rollbackTargetCheckpointId !== undefined ? (function (sql) {
-          var promises = allEntities.map(function (entityConfig) {
-                return EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, rollbackTargetCheckpointId);
-              });
-          promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, rollbackTargetCheckpointId));
-          return Promise.all(promises);
-        }) : undefined;
+              let entityHistory = getEntityHistory(entityConfig);
+              promises.push(setOrThrow(sql, batchSetUpdates, entityHistory.table, entityHistory.setChangeSchema, pgSchema));
+            }
+          }
+          if (Utils.$$Array.notEmpty(entitiesToSet)) {
+            if (shouldRemoveInvalidUtf8) {
+              removeInvalidUtf8InPlace(entitiesToSet);
+            }
+            promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, entityConfig.schema, pgSchema));
+          }
+          if (Utils.$$Array.notEmpty(idsToDelete)) {
+            promises.push(deleteByIdsOrThrow(sql, pgSchema, idsToDelete, entityConfig.table));
+          }
+          await Promise.all(promises);
+          return;
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let normalizedExn = Primitive_exceptions.internalToException(exn.RE_EXN_ID === "JsExn" || exn.RE_EXN_ID !== Persistence.StorageError ? exn : exn.reason);
+          if (normalizedExn.RE_EXN_ID === "JsExn") {
+            let val;
+            try {
+              val = S$RescriptSchema.parseOrThrow(normalizedExn._1, pgErrorMessageSchema);
+            } catch (exn$1) {
+              return;
+            }
+            switch (val) {
+              case "current transaction is aborted, commands ignored until end of transaction block" :
+                return;
+              case "invalid byte sequence for encoding \"UTF8\": 0x00" :
+                specificError.contents = {
+                  RE_EXN_ID: PgEncodingError,
+                  table: entityConfig.table
+                };
+                return;
+              default:
+                specificError.contents = Utils.prettifyExn(exn);
+                return;
+            }
+          } else {
+            if (normalizedExn.RE_EXN_ID !== S$RescriptSchema.Raised) {
+              return;
+            }
+            throw normalizedExn;
+          }
+        }
+      };
+    });
+    let rollbackTables = rollbackTargetCheckpointId !== undefined ? sql => {
+        let promises = allEntities.map(entityConfig => EntityHistory.rollback(sql, pgSchema, entityConfig.name, entityConfig.index, rollbackTargetCheckpointId));
+        promises.push(InternalTable.Checkpoints.rollback(sql, pgSchema, rollbackTargetCheckpointId));
+        return Promise.all(promises);
+      } : undefined;
     try {
       await Promise.all([
-            sql.begin(async function (sql) {
-                  if (rollbackTables !== undefined) {
-                    await rollbackTables(sql);
-                  }
-                  var setOperations = Belt_Array.concat([
-                        (function (sql) {
-                            return InternalTable.Chains.setProgressedChains(sql, pgSchema, Utils.Dict.mapValuesToArray(batch.progressedChainsById, (function (chainAfterBatch) {
-                                              return {
-                                                      chainId: chainAfterBatch.fetchState.chainId,
-                                                      progressBlockNumber: chainAfterBatch.progressBlockNumber,
-                                                      sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
-                                                      totalEventsProcessed: chainAfterBatch.totalEventsProcessed
-                                                    };
-                                            })));
-                          }),
-                        setRawEvents
-                      ], setEntities);
-                  if (shouldSaveHistory) {
-                    setOperations.push(function (sql) {
-                          return InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed);
-                        });
-                  }
-                  await Promise.all(Belt_Array.map(setOperations, (function (dbFunc) {
-                              return dbFunc(sql);
-                            })));
-                  if (sinkPromise === undefined) {
-                    return ;
-                  }
-                  var exn = await Caml_option.valFromOption(sinkPromise);
-                  if (exn === undefined) {
-                    return ;
-                  }
-                  throw exn;
-                }),
-            Promise.all(Belt_Array.map(updatedEffectsCache, (function (param) {
-                        return setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize);
-                      })))
-          ]);
-      var specificError$1 = specificError.contents;
+        sql.begin(async sql => {
+          if (rollbackTables !== undefined) {
+            await rollbackTables(sql);
+          }
+          let setOperations = Belt_Array.concat([
+            sql => InternalTable.Chains.setProgressedChains(sql, pgSchema, Utils.Dict.mapValuesToArray(batch.progressedChainsById, chainAfterBatch => ({
+              chainId: chainAfterBatch.fetchState.chainId,
+              progressBlockNumber: chainAfterBatch.progressBlockNumber,
+              sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
+              totalEventsProcessed: chainAfterBatch.totalEventsProcessed
+            }))),
+            setRawEvents
+          ], setEntities);
+          if (shouldSaveHistory) {
+            setOperations.push(sql => InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed));
+          }
+          await Promise.all(Belt_Array.map(setOperations, dbFunc => dbFunc(sql)));
+          if (sinkPromise === undefined) {
+            return;
+          }
+          let exn = await sinkPromise;
+          if (exn === undefined) {
+            return;
+          }
+          throw exn;
+        }),
+        Promise.all(Belt_Array.map(updatedEffectsCache, param => setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize)))
+      ]);
+      let specificError$1 = specificError.contents;
       if (specificError$1 === undefined) {
-        return ;
+        return;
       }
       throw specificError$1;
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-      var specificError$2 = specificError.contents;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let specificError$2 = specificError.contents;
       throw specificError$2 !== undefined ? specificError$2 : exn;
     }
-  }
-  catch (raw_exn$1){
-    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+  } catch (raw_exn$1) {
+    let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
     if (exn$1.RE_EXN_ID === PgEncodingError) {
-      var escapeTables$1 = escapeTables !== undefined ? Caml_option.valFromOption(escapeTables) : new Set();
+      let escapeTables$1 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Caml_option.some(escapeTables$1));
+      return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Primitive_option.some(escapeTables$1));
     }
     throw exn$1;
   }
 }
 
 function makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema) {
-  var dataFieldNames = Belt_Array.keepMap(entityConfig.table.fields, (function (fieldOrDerived) {
-          if (fieldOrDerived.TAG === "Field") {
-            return Table.getDbFieldName(fieldOrDerived._0);
-          }
-          
-        }));
-  var dataFieldsCommaSeparated = Belt_Array.map(dataFieldNames, (function (name) {
-            return "\"" + name + "\"";
-          })).join(", ");
-  var historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return "SELECT DISTINCT ON (" + Table.idFieldName + ") " + dataFieldsCommaSeparated + "\nFROM \"" + pgSchema + "\".\"" + historyTableName + "\"\nWHERE \"" + EntityHistory.checkpointIdFieldName + "\" <= $1\n  AND EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName + "\" h\n    WHERE h." + Table.idFieldName + " = \"" + historyTableName + "\"." + Table.idFieldName + "\n      AND h.\"" + EntityHistory.checkpointIdFieldName + "\" > $1\n  )\nORDER BY " + Table.idFieldName + ", \"" + EntityHistory.checkpointIdFieldName + "\" DESC";
+  let dataFieldNames = Belt_Array.keepMap(entityConfig.table.fields, fieldOrDerived => {
+    if (fieldOrDerived.TAG === "Field") {
+      return Table.getDbFieldName(fieldOrDerived._0);
+    }
+  });
+  let dataFieldsCommaSeparated = Belt_Array.map(dataFieldNames, name => `"` + name + `"`).join(", ");
+  let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  return `SELECT DISTINCT ON (` + Table.idFieldName + `) ` + dataFieldsCommaSeparated + `
+FROM "` + pgSchema + `"."` + historyTableName + `"
+WHERE "` + EntityHistory.checkpointIdFieldName + `" <= $1
+  AND EXISTS (
+    SELECT 1
+    FROM "` + pgSchema + `"."` + historyTableName + `" h
+    WHERE h.` + Table.idFieldName + ` = "` + historyTableName + `".` + Table.idFieldName + `
+      AND h."` + EntityHistory.checkpointIdFieldName + `" > $1
+  )
+ORDER BY ` + Table.idFieldName + `, "` + EntityHistory.checkpointIdFieldName + `" DESC`;
 }
 
 function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema) {
-  var historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return "SELECT DISTINCT " + Table.idFieldName + "\nFROM \"" + pgSchema + "\".\"" + historyTableName + "\"\nWHERE \"" + EntityHistory.checkpointIdFieldName + "\" > $1\nAND NOT EXISTS (\n  SELECT 1\n  FROM \"" + pgSchema + "\".\"" + historyTableName + "\" h\n  WHERE h." + Table.idFieldName + " = \"" + historyTableName + "\"." + Table.idFieldName + "\n    AND h.\"" + EntityHistory.checkpointIdFieldName + "\" <= $1\n)";
+  let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  return `SELECT DISTINCT ` + Table.idFieldName + `
+FROM "` + pgSchema + `"."` + historyTableName + `"
+WHERE "` + EntityHistory.checkpointIdFieldName + `" > $1
+AND NOT EXISTS (
+  SELECT 1
+  FROM "` + pgSchema + `"."` + historyTableName + `" h
+  WHERE h.` + Table.idFieldName + ` = "` + historyTableName + `".` + Table.idFieldName + `
+    AND h."` + EntityHistory.checkpointIdFieldName + `" <= $1
+)`;
 }
 
 function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, sink, onInitialize, onNewTables) {
-  var containerName = "envio-postgres";
-  var psqlExecOptions_env = Js_dict.fromArray([
-        [
-          "PGPASSWORD",
-          pgPassword
-        ],
-        [
-          "PATH",
-          process.env.PATH
-        ]
-      ]);
-  var psqlExecOptions = {
+  let containerName = "envio-postgres";
+  let psqlExecOptions_env = Object.fromEntries([
+    [
+      "PGPASSWORD",
+      pgPassword
+    ],
+    [
+      "PATH",
+      process.env.PATH
+    ]
+  ]);
+  let psqlExecOptions = {
     env: psqlExecOptions_env
   };
-  var cacheDirPath = Path.resolve(".envio", "cache");
-  var isInitialized = async function () {
-    var envioTables = await sql.unsafe("SELECT table_schema FROM information_schema.tables WHERE table_schema = '" + pgSchema + "' AND (table_name = 'event_sync_state' OR table_name = '" + InternalTable.Chains.table.tableName + "');");
-    return Utils.$$Array.notEmpty(envioTables);
-  };
-  var restoreEffectCache = async function (withUpload) {
+  let cacheDirPath = Path.resolve(".envio", "cache");
+  let isInitialized = async () => Utils.$$Array.notEmpty(await sql.unsafe(`SELECT table_schema FROM information_schema.tables WHERE table_schema = '` + pgSchema + `' AND (table_name = '` + "event_sync_state" + `' OR table_name = '` + InternalTable.Chains.table.tableName + `');`));
+  let restoreEffectCache = async withUpload => {
     if (withUpload) {
-      var nothingToUploadErrorMessage = "Nothing to upload.";
-      var match = await Promise.all([
-            $$Promise.$$catch(Fs.promises.readdir(cacheDirPath).then(function (e) {
-                      return {
-                              TAG: "Ok",
-                              _0: e
-                            };
-                    }), (function (param) {
-                    return Promise.resolve({
-                                TAG: "Error",
-                                _0: nothingToUploadErrorMessage
-                              });
-                  })),
-            getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName)
-          ]);
-      var exit = 0;
-      var message;
-      var entries = match[0];
+      let nothingToUploadErrorMessage = "Nothing to upload.";
+      let match = await Promise.all([
+        Stdlib_Promise.$$catch(Fs.promises.readdir(cacheDirPath).then(e => ({
+          TAG: "Ok",
+          _0: e
+        })), param => Promise.resolve({
+          TAG: "Error",
+          _0: nothingToUploadErrorMessage
+        })),
+        getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName)
+      ]);
+      let exit = 0;
+      let message;
+      let entries = match[0];
       if (entries.TAG === "Ok") {
-        var psqlExec = match[1];
+        let psqlExec = match[1];
         if (psqlExec.TAG === "Ok") {
-          var psqlExec$1 = psqlExec._0;
-          var cacheFiles = entries._0.filter(function (entry) {
-                return entry.endsWith(".tsv");
+          let psqlExec$1 = psqlExec._0;
+          let cacheFiles = entries._0.filter(entry => entry.endsWith(".tsv"));
+          await Promise.all(cacheFiles.map(entry => {
+            let effectName = entry.slice(0, -4);
+            let table = Internal.makeCacheTable(effectName);
+            return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(() => {
+              let inputFile = Path.join(cacheDirPath, entry);
+              let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + table.tableName + `" FROM STDIN WITH (FORMAT text, HEADER);' < ` + inputFile;
+              return new Promise((resolve, reject) => {
+                Child_process.exec(command, psqlExecOptions, (error, stdout, param) => {
+                  if (error === null) {
+                    return resolve(stdout);
+                  } else {
+                    return reject(error);
+                  }
+                });
               });
-          await Promise.all(cacheFiles.map(function (entry) {
-                    var effectName = entry.slice(0, -4);
-                    var table = Internal.makeCacheTable(effectName);
-                    return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(function () {
-                                var inputFile = Path.join(cacheDirPath, entry);
-                                var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + table.tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
-                                return new Promise((function (resolve, reject) {
-                                              Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
-                                                      if (error === null) {
-                                                        return resolve(stdout);
-                                                      } else {
-                                                        return reject(error);
-                                                      }
-                                                    }));
-                                            }));
-                              });
-                  }));
+            });
+          }));
           Logging.info("Successfully uploaded cache.");
         } else {
           message = match[1]._0;
@@ -812,343 +772,363 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         if (message === nothingToUploadErrorMessage) {
           Logging.info("No cache found to upload.");
         } else {
-          Logging.error("Failed to upload cache, continuing without it. " + message);
+          Logging.error(`Failed to upload cache, continuing without it. ` + message);
         }
       }
-      
     }
-    var cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
+    let cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
     if (withUpload && Utils.$$Array.notEmpty(cacheTableInfo) && onNewTables !== undefined) {
-      await onNewTables(cacheTableInfo.map(function (info) {
-                return info.table_name;
-              }));
+      await onNewTables(cacheTableInfo.map(info => info.table_name));
     }
-    var cache = {};
-    cacheTableInfo.forEach(function (param) {
-          var effectName = param.table_name.slice(cacheTablePrefixLength);
-          cache[effectName] = {
-            effectName: effectName,
-            count: param.count
-          };
-        });
+    let cache = {};
+    cacheTableInfo.forEach(param => {
+      let effectName = param.table_name.slice(cacheTablePrefixLength);
+      cache[effectName] = {
+        effectName: effectName,
+        count: param.count
+      };
+    });
     return cache;
   };
-  var initialize = async function (chainConfigsOpt, entitiesOpt, enumsOpt) {
-    var chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
-    var entities = entitiesOpt !== undefined ? entitiesOpt : [];
-    var enums = enumsOpt !== undefined ? enumsOpt : [];
-    var schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
-    if (Utils.$$Array.notEmpty(schemaTableNames) && !schemaTableNames.some(function (table) {
-            return table.table_name === InternalTable.Chains.table.tableName ? true : table.table_name === "event_sync_state";
-          })) {
-      Js_exn.raiseError("Cannot run Envio migrations on PostgreSQL schema \"" + pgSchema + "\" because it contains non-Envio tables. Running migrations would delete all data in this schema.\n\nTo resolve this:\n1. If you want to use this schema, first backup any important data, then drop it with: \"pnpm envio local db-migrate down\"\n2. Or specify a different schema name by setting the \"ENVIO_PG_SCHEMA\" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.");
+  let initialize = async (chainConfigsOpt, entitiesOpt, enumsOpt) => {
+    let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
+    let entities = entitiesOpt !== undefined ? entitiesOpt : [];
+    let enums = enumsOpt !== undefined ? enumsOpt : [];
+    let schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
+    if (Utils.$$Array.notEmpty(schemaTableNames) && !schemaTableNames.some(table => table.table_name === InternalTable.Chains.table.tableName ? true : table.table_name === "event_sync_state")) {
+      Stdlib_JsError.throwWithMessage(`Cannot run Envio migrations on PostgreSQL schema "` + pgSchema + `" because it contains non-Envio tables. Running migrations would delete all data in this schema.\n\nTo resolve this:\n1. If you want to use this schema, first backup any important data, then drop it with: "pnpm envio local db-migrate down"\n2. Or specify a different schema name by setting the "ENVIO_PG_SCHEMA" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.`);
     }
     if (sink !== undefined) {
       await sink.initialize(chainConfigs, entities, enums);
     }
-    var queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
-    await sql.begin(function (sql) {
-          return Promise.all(queries.map(function (query) {
-                          return sql.unsafe(query);
-                        }));
+    let queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
+    await sql.begin(sql => Promise.all(queries.map(query => sql.unsafe(query))));
+    let ids = [];
+    let addrChainIds = [];
+    let addrContractNames = [];
+    chainConfigs.forEach(chain => {
+      chain.contracts.forEach(contract => {
+        contract.addresses.forEach(address => {
+          ids.push(Config.EnvioAddresses.makeId(chain.id, address));
+          addrChainIds.push(chain.id);
+          addrContractNames.push(contract.name);
         });
-    var cache = await restoreEffectCache(true);
+      });
+    });
+    if (ids.length !== 0) {
+      await sql.unsafe(`INSERT INTO "` + pgSchema + `"."` + Config.EnvioAddresses.table.tableName + `" ("id", "chain_id", "registration_block", "registration_log_index", "contract_name")
+SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::text[]) AS t(id, chain_id, contract_name);`, [
+        ids,
+        addrChainIds,
+        addrContractNames
+      ]);
+    }
+    let cache = await restoreEffectCache(true);
     if (onInitialize !== undefined) {
       await onInitialize();
     }
     return {
-            cleanRun: true,
-            cache: cache,
-            chains: chainConfigs.map(function (chainConfig) {
-                  return {
-                          id: chainConfig.id,
-                          startBlock: chainConfig.startBlock,
-                          endBlock: chainConfig.endBlock,
-                          maxReorgDepth: chainConfig.maxReorgDepth,
-                          progressBlockNumber: -1,
-                          numEventsProcessed: 0,
-                          firstEventBlockNumber: undefined,
-                          timestampCaughtUpToHeadOrEndblock: undefined,
-                          dynamicContracts: [],
-                          sourceBlockNumber: 0
-                        };
-                }),
-            checkpointId: InternalTable.Checkpoints.initialCheckpointId,
-            reorgCheckpoints: []
-          };
+      cleanRun: true,
+      cache: cache,
+      chains: chainConfigs.map(chainConfig => ({
+        id: chainConfig.id,
+        startBlock: chainConfig.startBlock,
+        endBlock: chainConfig.endBlock,
+        maxReorgDepth: chainConfig.maxReorgDepth,
+        progressBlockNumber: -1,
+        numEventsProcessed: 0,
+        firstEventBlockNumber: undefined,
+        timestampCaughtUpToHeadOrEndblock: undefined,
+        indexingAddresses: ChainFetcher.configAddresses(chainConfig),
+        sourceBlockNumber: 0
+      })),
+      checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+      reorgCheckpoints: []
+    };
   };
-  var loadByIdsOrThrow = async function (ids, table, rowsSchema) {
-    var rows;
+  let loadByIdsOrThrow = async (ids, table, rowsSchema) => {
+    let rows;
     try {
       rows = await (
         ids.length !== 1 ? sql.unsafe(makeLoadByIdsQuery(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeLoadByIdQuery(pgSchema, table.tableName), ids, {prepare: true})
       );
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
-            RE_EXN_ID: Persistence.StorageError,
-            message: "Failed loading \"" + table.tableName + "\" from storage by ids",
-            reason: exn,
-            Error: new Error()
-          };
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed loading "` + table.tableName + `" from storage by ids`,
+        reason: exn,
+        Error: new Error()
+      };
     }
     try {
       return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
-    }
-    catch (raw_exn$1){
-      var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+    } catch (raw_exn$1) {
+      let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
       throw {
-            RE_EXN_ID: Persistence.StorageError,
-            message: "Failed to parse \"" + table.tableName + "\" loaded from storage by ids",
-            reason: exn$1,
-            Error: new Error()
-          };
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed to parse "` + table.tableName + `" loaded from storage by ids`,
+        reason: exn$1,
+        Error: new Error()
+      };
     }
   };
-  var loadByFieldOrThrow = async function (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) {
-    var params;
+  let loadByFieldOrThrow = async (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) => {
+    let params;
     try {
       params = [S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema)];
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
-            RE_EXN_ID: Persistence.StorageError,
-            message: "Failed loading \"" + table.tableName + "\" from storage by field \"" + fieldName + "\". Couldn't serialize provided value.",
-            reason: exn,
-            Error: new Error()
-          };
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed loading "` + table.tableName + `" from storage by field "` + fieldName + `". Couldn't serialize provided value.`,
+        reason: exn,
+        Error: new Error()
+      };
     }
-    var rows;
+    let rows;
     try {
       rows = await sql.unsafe(makeLoadByFieldQuery(pgSchema, table.tableName, fieldName, operator), params, {prepare: true});
-    }
-    catch (raw_exn$1){
-      var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+    } catch (raw_exn$1) {
+      let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
       throw {
-            RE_EXN_ID: Persistence.StorageError,
-            message: "Failed loading \"" + table.tableName + "\" from storage by field \"" + fieldName + "\"",
-            reason: exn$1,
-            Error: new Error()
-          };
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed loading "` + table.tableName + `" from storage by field "` + fieldName + `"`,
+        reason: exn$1,
+        Error: new Error()
+      };
     }
     try {
       return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
-    }
-    catch (raw_exn$2){
-      var exn$2 = Caml_js_exceptions.internalToOCamlException(raw_exn$2);
+    } catch (raw_exn$2) {
+      let exn$2 = Primitive_exceptions.internalToException(raw_exn$2);
       throw {
-            RE_EXN_ID: Persistence.StorageError,
-            message: "Failed to parse \"" + table.tableName + "\" loaded from storage by ids",
-            reason: exn$2,
-            Error: new Error()
-          };
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed to parse "` + table.tableName + `" loaded from storage by ids`,
+        reason: exn$2,
+        Error: new Error()
+      };
     }
   };
-  var setOrThrow$1 = function (items, table, itemSchema) {
-    return setOrThrow(sql, items, table, itemSchema, pgSchema);
-  };
-  var setEffectCacheOrThrow = async function (effect, items, initialize) {
-    var match = effect.storageMeta;
-    var table = match.table;
+  let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema);
+  let setEffectCacheOrThrow = async (effect, items, initialize) => {
+    let match = effect.storageMeta;
+    let table = match.table;
     if (initialize) {
       await sql.unsafe(makeCreateTableQuery(table, pgSchema, false));
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }
-      
     }
     return await setOrThrow$1(items, table, match.itemSchema);
   };
-  var dumpEffectCache = async function () {
+  let dumpEffectCache = async () => {
     try {
-      var cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(function (i) {
-            return i.count > 0;
-          });
+      let cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(i => i.count > 0);
       if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
-        return ;
+        return;
       }
       try {
         await Fs.promises.access(cacheDirPath);
-      }
-      catch (exn){
+      } catch (exn) {
         await Fs.promises.mkdir(cacheDirPath, {
-              recursive: true
-            });
+          recursive: true
+        });
       }
-      var psqlExec = await getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName);
+      let psqlExec = await getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName);
       if (psqlExec.TAG !== "Ok") {
-        return Logging.error("Failed to dump cache. " + psqlExec._0);
+        return Logging.error(`Failed to dump cache. ` + psqlExec._0);
       }
-      var psqlExec$1 = psqlExec._0;
-      Logging.info("Dumping cache: " + cacheTableInfo.map(function (param) {
-                  return param.table_name + " (" + String(param.count) + " rows)";
-                }).join(", "));
-      var promises = cacheTableInfo.map(async function (param) {
-            var tableName = param.table_name;
-            var cacheName = tableName.slice(cacheTablePrefixLength);
-            var outputFile = Path.join(cacheDirPath, cacheName + ".tsv");
-            var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" TO STDOUT WITH (FORMAT text, HEADER);' > " + outputFile;
-            return new Promise((function (resolve, reject) {
-                          Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
-                                  if (error === null) {
-                                    return resolve(stdout);
-                                  } else {
-                                    return reject(error);
-                                  }
-                                }));
-                        }));
+      let psqlExec$1 = psqlExec._0;
+      Logging.info(`Dumping cache: ` + cacheTableInfo.map(param => param.table_name + " (" + String(param.count) + " rows)").join(", "));
+      let promises = cacheTableInfo.map(async param => {
+        let tableName = param.table_name;
+        let cacheName = tableName.slice(cacheTablePrefixLength);
+        let outputFile = Path.join(cacheDirPath, cacheName + ".tsv");
+        let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + tableName + `" TO STDOUT WITH (FORMAT text, HEADER);' > ` + outputFile;
+        return new Promise((resolve, reject) => {
+          Child_process.exec(command, psqlExecOptions, (error, stdout, param) => {
+            if (error === null) {
+              return resolve(stdout);
+            } else {
+              return reject(error);
+            }
           });
+        });
+      });
       await Promise.all(promises);
-      return Logging.info("Successfully dumped cache to " + cacheDirPath);
-    }
-    catch (raw_exn){
-      var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn);
-      return Logging.errorWithExn(Utils.prettifyExn(exn$1), "Failed to dump cache.");
+      return Logging.info(`Successfully dumped cache to ` + cacheDirPath);
+    } catch (raw_exn) {
+      let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+      return Logging.errorWithExn(Utils.prettifyExn(exn$1), `Failed to dump cache.`);
     }
   };
-  var resumeInitialState = async function () {
-    var match = await Promise.all([
-          restoreEffectCache(false),
-          InternalTable.Chains.getInitialState(sql, pgSchema).then(function (rawInitialStates) {
-                return Belt_Array.map(rawInitialStates, (function (rawInitialState) {
-                              return {
-                                      id: rawInitialState.id,
-                                      startBlock: rawInitialState.startBlock,
-                                      endBlock: Caml_option.null_to_opt(rawInitialState.endBlock),
-                                      maxReorgDepth: rawInitialState.maxReorgDepth,
-                                      progressBlockNumber: rawInitialState.progressBlockNumber,
-                                      numEventsProcessed: rawInitialState.numEventsProcessed,
-                                      firstEventBlockNumber: Caml_option.null_to_opt(rawInitialState.firstEventBlockNumber),
-                                      timestampCaughtUpToHeadOrEndblock: Caml_option.null_to_opt(rawInitialState.timestampCaughtUpToHeadOrEndblock),
-                                      dynamicContracts: rawInitialState.dynamicContracts,
-                                      sourceBlockNumber: rawInitialState.sourceBlockNumber
-                                    };
-                            }));
-              }),
-          sql.unsafe(InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(pgSchema)),
-          sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema))
-        ]);
-    var checkpointId = BigInt(match[2][0].id);
-    var reorgCheckpoints = Belt_Array.map(match[3], (function (raw) {
-            return {
-                    id: BigInt(raw.id),
-                    chain_id: raw.chain_id,
-                    block_number: raw.block_number,
-                    block_hash: raw.block_hash
-                  };
-          }));
+  let resumeInitialState = async () => {
+    let match = await Promise.all([
+      restoreEffectCache(false),
+      InternalTable.Chains.getInitialState(sql, pgSchema).then(rawInitialStates => Belt_Array.map(rawInitialStates, rawInitialState => ({
+        id: rawInitialState.id,
+        startBlock: rawInitialState.startBlock,
+        endBlock: Primitive_option.fromNull(rawInitialState.endBlock),
+        maxReorgDepth: rawInitialState.maxReorgDepth,
+        progressBlockNumber: rawInitialState.progressBlockNumber,
+        numEventsProcessed: rawInitialState.numEventsProcessed,
+        firstEventBlockNumber: Primitive_option.fromNull(rawInitialState.firstEventBlockNumber),
+        timestampCaughtUpToHeadOrEndblock: Primitive_option.fromNull(rawInitialState.timestampCaughtUpToHeadOrEndblock),
+        indexingAddresses: rawInitialState.indexingAddresses,
+        sourceBlockNumber: rawInitialState.sourceBlockNumber
+      }))),
+      sql.unsafe(InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(pgSchema)),
+      sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema))
+    ]);
+    let checkpointId = BigInt(match[2][0].id);
+    let reorgCheckpoints = Belt_Array.map(match[3], raw => ({
+      id: BigInt(raw.id),
+      chain_id: raw.chain_id,
+      block_number: raw.block_number,
+      block_hash: raw.block_hash
+    }));
     if (sink !== undefined) {
       await sink.resume(checkpointId);
     }
     return {
-            cleanRun: false,
-            cache: match[0],
-            chains: match[1],
-            checkpointId: checkpointId,
-            reorgCheckpoints: reorgCheckpoints
-          };
+      cleanRun: false,
+      cache: match[0],
+      chains: match[1],
+      checkpointId: checkpointId,
+      reorgCheckpoints: reorgCheckpoints
+    };
   };
-  var reset = async function () {
-    var query = "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;";
+  let reset = async () => {
+    let query = `DROP SCHEMA IF EXISTS "` + pgSchema + `" CASCADE;`;
     return await sql.unsafe(query);
   };
-  var setChainMeta = function (chainsData) {
-    return InternalTable.Chains.setMeta(sql, pgSchema, chainsData).then(function (param) {
-                return undefined;
-              });
-  };
-  var pruneStaleCheckpoints = function (safeCheckpointId) {
-    return InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId);
-  };
-  var pruneStaleEntityHistory = function (entityName, entityIndex, safeCheckpointId) {
-    return EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId);
-  };
-  var getRollbackTargetCheckpoint = function (reorgChainId, lastKnownValidBlockNumber) {
-    return InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
-  };
-  var getRollbackProgressDiff = function (rollbackTargetCheckpointId) {
-    return InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
-  };
-  var getRollbackData = async function (entityConfig, rollbackTargetCheckpointId) {
-    return await Promise.all([
-                sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
-                sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
-              ]);
-  };
-  var writeBatchMethod = async function (batch, rawEvents, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) {
-    var sinkPromise;
+  let setChainMeta = chainsData => InternalTable.Chains.setMeta(sql, pgSchema, chainsData).then(param => (undefined));
+  let pruneStaleCheckpoints = safeCheckpointId => InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId);
+  let pruneStaleEntityHistory = (entityName, entityIndex, safeCheckpointId) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId);
+  let getRollbackTargetCheckpoint = (reorgChainId, lastKnownValidBlockNumber) => InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
+  let getRollbackProgressDiff = rollbackTargetCheckpointId => InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
+  let getRollbackData = async (entityConfig, rollbackTargetCheckpointId) => await Promise.all([
+    sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
+    sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
+  ]);
+  let writeBatchMethod = async (batch, rawEvents, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) => {
+    let sinkPromise;
     if (sink !== undefined) {
-      var timerRef = Hrtime.makeTimer();
-      sinkPromise = Caml_option.some(sink.writeBatch(batch, updatedEntities).then(function () {
-                  Prometheus.SinkWrite.increment(sink.name, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
-                }).catch(function (exn) {
-                return exn;
-              }));
+      let timerRef = Hrtime.makeTimer();
+      sinkPromise = sink.writeBatch(batch, updatedEntities).then(() => {
+        Prometheus.StorageWrite.increment(sink.name, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+      }).catch(exn => exn);
     } else {
       sinkPromise = undefined;
     }
-    return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, undefined);
+    let primaryTimerRef = Hrtime.makeTimer();
+    await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, undefined);
+    return Prometheus.StorageWrite.increment("postgres", Hrtime.toSecondsFloat(Hrtime.timeSince(primaryTimerRef)));
   };
   return {
-          isInitialized: isInitialized,
-          initialize: initialize,
-          resumeInitialState: resumeInitialState,
-          loadByIdsOrThrow: loadByIdsOrThrow,
-          loadByFieldOrThrow: loadByFieldOrThrow,
-          dumpEffectCache: dumpEffectCache,
-          reset: reset,
-          setChainMeta: setChainMeta,
-          pruneStaleCheckpoints: pruneStaleCheckpoints,
-          pruneStaleEntityHistory: pruneStaleEntityHistory,
-          getRollbackTargetCheckpoint: getRollbackTargetCheckpoint,
-          getRollbackProgressDiff: getRollbackProgressDiff,
-          getRollbackData: getRollbackData,
-          writeBatch: writeBatchMethod
-        };
+    name: "postgres",
+    isInitialized: isInitialized,
+    initialize: initialize,
+    resumeInitialState: resumeInitialState,
+    loadByIdsOrThrow: loadByIdsOrThrow,
+    loadByFieldOrThrow: loadByFieldOrThrow,
+    dumpEffectCache: dumpEffectCache,
+    reset: reset,
+    setChainMeta: setChainMeta,
+    pruneStaleCheckpoints: pruneStaleCheckpoints,
+    pruneStaleEntityHistory: pruneStaleEntityHistory,
+    getRollbackTargetCheckpoint: getRollbackTargetCheckpoint,
+    getRollbackProgressDiff: getRollbackProgressDiff,
+    getRollbackData: getRollbackData,
+    writeBatch: writeBatchMethod
+  };
+}
+
+function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
+  let sql = sqlOpt !== undefined ? Primitive_option.valFromOption(sqlOpt) : makeClient();
+  let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
+  let isHasuraEnabled = isHasuraEnabledOpt !== undefined ? isHasuraEnabledOpt : Env.Hasura.enabled;
+  let tmp;
+  if (config.storage.clickhouse) {
+    let host = Env.ClickHouse.host();
+    let username = Env.ClickHouse.username();
+    let password = Env.ClickHouse.password();
+    let missing = [];
+    let checkEnv = (opt, name) => {
+      if (opt !== undefined) {
+        return;
+      } else {
+        missing.push(name);
+        return;
+      }
+    };
+    checkEnv(host, "ENVIO_CLICKHOUSE_HOST");
+    checkEnv(username, "ENVIO_CLICKHOUSE_USERNAME");
+    checkEnv(password, "ENVIO_CLICKHOUSE_PASSWORD");
+    if (missing.length !== 0) {
+      Stdlib_JsError.throwWithMessage(`ClickHouse storage is enabled but required env vars are not set: ` + missing.join(", ") + `. Please set them, disable clickhouse in the \`storage\` config, or run \`envio dev\` for a pre-configured local ClickHouse.`);
+    }
+    tmp = Sink.makeClickHouse(host, Env.ClickHouse.database(), username, password);
+  } else {
+    tmp = undefined;
+  }
+  return make(sql, Env.Db.host, pgSchema, Env.Db.port, Env.Db.user, Env.Db.database, Env.Db.password, isHasuraEnabled, tmp, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(Env.Hasura.graphqlEndpoint, {
+      role: Env.Hasura.role,
+      secret: Env.Hasura.secret
+    }, pgSchema, config.userEntities, Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(Belt_Array.map(config.allEntities, e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
+      role: Env.Hasura.role,
+      secret: Env.Hasura.secret
+    }, pgSchema, tableNames), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking new tables`))) : undefined);
+}
+
+function makePersistenceFromConfig(config, storageOpt) {
+  let storage = storageOpt !== undefined ? storageOpt : makeStorageFromEnv(config, undefined, undefined, undefined);
+  return Persistence.make(config.userEntities, config.allEnums, storage);
 }
 
-var maxItemsPerQuery = 500;
+let maxItemsPerQuery = 500;
 
 export {
-  getCacheRowCountFnName ,
-  makeClient ,
-  makeCreateIndexQuery ,
-  directionToSql ,
-  directionToIndexName ,
-  makeCreateCompositeIndexQuery ,
-  makeCreateTableIndicesQuery ,
-  makeCreateTableQuery ,
-  entityHistoryCache ,
-  getEntityHistory ,
-  makeInitializeTransaction ,
-  makeLoadByIdQuery ,
-  makeLoadByFieldQuery ,
-  makeLoadByIdsQuery ,
-  makeDeleteByIdQuery ,
-  makeDeleteByIdsQuery ,
-  makeLoadAllQuery ,
-  makeInsertUnnestSetQuery ,
-  makeInsertValuesSetQuery ,
-  maxItemsPerQuery ,
-  makeTableBatchSetQuery ,
-  chunkArray ,
-  removeInvalidUtf8InPlace ,
-  pgErrorMessageSchema ,
-  PgEncodingError ,
-  setQueryCache ,
-  setOrThrow ,
-  makeSchemaTableNamesQuery ,
-  cacheTablePrefixLength ,
-  makeSchemaCacheTableInfoQuery ,
-  getConnectedPsqlExec ,
-  deleteByIdsOrThrow ,
-  makeInsertDeleteUpdatesQuery ,
-  executeSet ,
-  writeBatch ,
-  makeGetRollbackRestoredEntitiesQuery ,
-  makeGetRollbackRemovedIdsQuery ,
-  make ,
+  getCacheRowCountFnName,
+  makeClient,
+  makeCreateIndexQuery,
+  directionToSql,
+  directionToIndexName,
+  makeCreateCompositeIndexQuery,
+  makeCreateTableIndicesQuery,
+  makeCreateTableQuery,
+  entityHistoryCache,
+  getEntityHistory,
+  makeInitializeTransaction,
+  makeLoadByIdQuery,
+  makeLoadByFieldQuery,
+  makeLoadByIdsQuery,
+  makeDeleteByIdQuery,
+  makeDeleteByIdsQuery,
+  makeLoadAllQuery,
+  makeInsertUnnestSetQuery,
+  makeInsertValuesSetQuery,
+  maxItemsPerQuery,
+  makeTableBatchSetQuery,
+  chunkArray,
+  removeInvalidUtf8InPlace,
+  pgErrorMessageSchema,
+  PgEncodingError,
+  setQueryCache,
+  setOrThrow,
+  makeSchemaTableNamesQuery,
+  cacheTablePrefixLength,
+  makeSchemaCacheTableInfoQuery,
+  getConnectedPsqlExec,
+  deleteByIdsOrThrow,
+  makeInsertDeleteUpdatesQuery,
+  executeSet,
+  writeBatch,
+  makeGetRollbackRestoredEntitiesQuery,
+  makeGetRollbackRemovedIdsQuery,
+  make,
+  makeStorageFromEnv,
+  makePersistenceFromConfig,
 }
 /* entityHistoryCache Not a pure module */