envio 2.26.0-alpha.9 → 2.26.0-rc.0

package/src/PgStorage.res.js

@@ -7,14 +7,13 @@ var Utils = require("./Utils.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Schema = require("./db/Schema.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
-var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_int32 = require("rescript/lib/js/caml_int32.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var Persistence = require("./Persistence.res.js");
-var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
-function makeCreateIndexQuery(tableName, indexFields, pgSchema) {
+function makeCreateIndexSql(tableName, indexFields, pgSchema) {
   var indexName = tableName + "_" + indexFields.join("_");
   var index = Belt_Array.map(indexFields, (function (idx) {
             return "\"" + idx + "\"";
@@ -22,20 +21,20 @@ function makeCreateIndexQuery(tableName, indexFields, pgSchema) {
   return "CREATE INDEX IF NOT EXISTS \"" + indexName + "\" ON \"" + pgSchema + "\".\"" + tableName + "\"(" + index + ");";
 }
 
-function makeCreateTableIndicesQuery(table, pgSchema) {
+function makeCreateTableIndicesSql(table, pgSchema) {
   var tableName = table.tableName;
   var createIndex = function (indexField) {
-    return makeCreateIndexQuery(tableName, [indexField], pgSchema);
+    return makeCreateIndexSql(tableName, [indexField], pgSchema);
   };
   var createCompositeIndex = function (indexFields) {
-    return makeCreateIndexQuery(tableName, indexFields, pgSchema);
+    return makeCreateIndexSql(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");
 }
 
-function makeCreateTableQuery(table, pgSchema) {
+function makeCreateTableSql(table, pgSchema) {
   var fieldsMapped = Belt_Array.map(Table.getFields(table), (function (field) {
             var defaultValue = field.defaultValue;
             var fieldType = field.fieldType;
@@ -59,11 +58,11 @@ function makeCreateTableQuery(table, pgSchema) {
         ) + ");";
 }
 
-function makeInitializeTransaction(pgSchema, pgUser, generalTablesOpt, entitiesOpt, enumsOpt, reuseExistingPgSchemaOpt) {
+function makeInitializeTransaction(pgSchema, pgUser, generalTablesOpt, entitiesOpt, enumsOpt, cleanRunOpt) {
   var generalTables = generalTablesOpt !== undefined ? generalTablesOpt : [];
   var entities = entitiesOpt !== undefined ? entitiesOpt : [];
   var enums = enumsOpt !== undefined ? enumsOpt : [];
-  var reuseExistingPgSchema = reuseExistingPgSchemaOpt !== undefined ? reuseExistingPgSchemaOpt : false;
+  var cleanRun = cleanRunOpt !== undefined ? cleanRunOpt : false;
   var allTables = $$Array.copy(generalTables);
   var allEntityTables = [];
   entities.forEach(function (entity) {
@@ -74,20 +73,22 @@ function makeInitializeTransaction(pgSchema, pgUser, generalTablesOpt, entitiesO
   var derivedSchema = Schema.make(allEntityTables);
   var query = {
     contents: (
-      reuseExistingPgSchema ? "" : "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;\nCREATE SCHEMA \"" + pgSchema + "\";\n"
-    ) + ("GRANT ALL ON SCHEMA \"" + pgSchema + "\" TO \"" + pgUser + "\";\nGRANT ALL ON SCHEMA \"" + pgSchema + "\" TO public;")
+      cleanRun ? "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;\nCREATE SCHEMA \"" + pgSchema + "\";" : "CREATE SCHEMA IF NOT EXISTS \"" + pgSchema + "\";"
+    ) + ("GRANT ALL ON SCHEMA \"" + pgSchema + "\" TO " + pgUser + ";\nGRANT 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;
+        query.contents = query.contents + "\n" + (
+          cleanRun ? enumCreateQuery : "IF NOT EXISTS (\n  SELECT 1 FROM pg_type \n  WHERE typname = '" + enumConfig.name.toLowerCase() + "' \n  AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '" + pgSchema + "')\n) THEN \n    " + enumCreateQuery + "\nEND IF;"
+        );
       });
   allTables.forEach(function (table) {
-        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema);
+        query.contents = query.contents + "\n" + makeCreateTableSql(table, pgSchema);
       });
   allTables.forEach(function (table) {
-        var indices = makeCreateTableIndicesQuery(table, pgSchema);
+        var indices = makeCreateTableIndicesSql(table, pgSchema);
         if (indices !== "") {
           query.contents = query.contents + "\n" + indices;
           return ;
@@ -101,26 +102,22 @@ function makeInitializeTransaction(pgSchema, pgUser, generalTablesOpt, entitiesO
         functionsQuery.contents = functionsQuery.contents + "\n" + entity.entityHistory.createInsertFnQuery;
         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);
+              query.contents = query.contents + "\n" + makeCreateIndexSql(derivedFromField.derivedFromEntity, [indexField], pgSchema);
             });
       });
-  return [query.contents].concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : []);
+  return [cleanRun || Utils.$$Array.isEmpty(enums) ? query.contents : "DO $$ BEGIN " + query.contents + " END $$;"].concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : []);
 }
 
-function makeLoadByIdQuery(pgSchema, tableName) {
+function makeLoadByIdSql(pgSchema, tableName) {
   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;";
-}
-
-function makeLoadByIdsQuery(pgSchema, tableName) {
+function makeLoadByIdsSql(pgSchema, tableName) {
   return "SELECT * FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE id = ANY($1::text[]);";
 }
 
-function makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
+function makeInsertUnnestSetSql(pgSchema, table, itemSchema, isRawEvents) {
+  var match = Table.toSqlParams(table, itemSchema);
   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) {
@@ -136,8 +133,8 @@ function makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents) {
         ) + ";";
 }
 
-function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
+function makeInsertValuesSetSql(pgSchema, table, itemSchema, itemsCount) {
+  var match = Table.toSqlParams(table, itemSchema);
   var quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
   var quotedFieldNames = match.quotedFieldNames;
   var primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
@@ -169,20 +166,18 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
 
 var rawEventsTableName = "raw_events";
 
-var eventSyncStateTableName = "event_sync_state";
-
 function makeTableBatchSetQuery(pgSchema, table, itemSchema) {
-  var match = Table.toSqlParams(table, itemSchema, pgSchema);
+  var match = Table.toSqlParams(table, itemSchema);
   var isRawEvents = table.tableName === rawEventsTableName;
   if (isRawEvents || !match.hasArrayField) {
     return {
-            query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
+            sql: makeInsertUnnestSetSql(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),
+            sql: makeInsertValuesSetSql(pgSchema, table, itemSchema, 500),
             convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), (function (param) {
                         return {
                                 s: (function (prim) {
@@ -206,24 +201,6 @@ function chunkArray(arr, chunkSize) {
   return chunks;
 }
 
-function removeInvalidUtf8InPlace(entities) {
-  entities.forEach(function (item) {
-        Utils.Dict.forEachWithKey(item, (function (key, value) {
-                if (typeof value === "string") {
-                  item[key] = value.replaceAll("\x00", "");
-                  return ;
-                }
-                
-              }));
-      });
-}
-
-var pgEncodingErrorSchema = S$RescriptSchema.object(function (s) {
-      s.tag("message", "invalid byte sequence for encoding \"UTF8\": 0x00");
-    });
-
-var PgEncodingError = /* @__PURE__ */Caml_exceptions.create("PgStorage.PgEncodingError");
-
 var setQueryCache = new WeakMap();
 
 async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
@@ -231,24 +208,30 @@ async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
     return ;
   }
   var cached = setQueryCache.get(table);
-  var data;
+  var query;
   if (cached !== undefined) {
-    data = Caml_option.valFromOption(cached);
+    query = Caml_option.valFromOption(cached);
   } else {
     var newQuery = makeTableBatchSetQuery(pgSchema, table, itemSchema);
     setQueryCache.set(table, newQuery);
-    data = newQuery;
+    query = newQuery;
   }
+  var sqlQuery = query.sql;
   try {
-    if (!data.isInsertValues) {
-      return await sql.unsafe(data.query, data.convertOrThrow(items), {prepare: true});
+    var payload = query.convertOrThrow(items);
+    if (!query.isInsertValues) {
+      return await sql.unsafe(sqlQuery, payload, {prepare: true});
     }
-    var chunks = chunkArray(items, 500);
+    var match = itemSchema.t;
+    var fieldsCount;
+    fieldsCount = typeof match !== "object" || match.TAG !== "object" ? Js_exn.raiseError("Expected an object schema for table") : match.items.length;
+    var maxChunkSize = Math.imul(500, fieldsCount);
+    var chunks = chunkArray(payload, maxChunkSize);
     var responses = [];
     chunks.forEach(function (chunk) {
           var chunkSize = chunk.length;
-          var isFullChunk = chunkSize === 500;
-          var response = sql.unsafe(isFullChunk ? data.query : makeInsertValuesSetQuery(pgSchema, table, itemSchema, chunkSize), data.convertOrThrow(chunk), {prepare: true});
+          var isFullChunk = chunkSize === maxChunkSize;
+          var response = sql.unsafe(isFullChunk ? sqlQuery : makeInsertValuesSetSql(pgSchema, table, itemSchema, Caml_int32.div(chunkSize, fieldsCount)), chunk, {prepare: true});
           responses.push(response);
         });
     await Promise.all(responses);
@@ -273,61 +256,28 @@ async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
   }
 }
 
-function setEntityHistoryOrThrow(sql, entityHistory, rows, shouldCopyCurrentEntity, shouldRemoveInvalidUtf8Opt) {
-  var shouldRemoveInvalidUtf8 = shouldRemoveInvalidUtf8Opt !== undefined ? shouldRemoveInvalidUtf8Opt : false;
-  return Promise.all(Belt_Array.map(rows, (function (historyRow) {
-                    var row = S$RescriptSchema.reverseConvertToJsonOrThrow(historyRow, entityHistory.schema);
-                    if (shouldRemoveInvalidUtf8) {
-                      removeInvalidUtf8InPlace([row]);
-                    }
-                    return entityHistory.insertFn(sql, row, shouldCopyCurrentEntity !== undefined ? shouldCopyCurrentEntity : !Belt_Option.getWithDefault(historyRow.containsRollbackDiffChange, false));
-                  })));
-}
-
-function makeSchemaTableNamesQuery(pgSchema) {
-  return "SELECT table_name FROM information_schema.tables WHERE table_schema = '" + pgSchema + "';";
-}
-
 function make(sql, pgSchema, pgUser) {
   var isInitialized = async function () {
-    var envioTables = await sql.unsafe("SELECT table_schema FROM information_schema.tables WHERE table_schema = '" + pgSchema + "' AND table_name = '" + eventSyncStateTableName + "';");
-    return Utils.$$Array.notEmpty(envioTables);
+    var schemas = await sql.unsafe("SELECT schema_name FROM information_schema.schemata WHERE schema_name = '" + pgSchema + "';");
+    return Utils.$$Array.notEmpty(schemas);
   };
-  var initialize = async function (entitiesOpt, generalTablesOpt, enumsOpt) {
+  var initialize = async function (entitiesOpt, generalTablesOpt, enumsOpt, cleanRunOpt) {
     var entities = entitiesOpt !== undefined ? entitiesOpt : [];
     var generalTables = generalTablesOpt !== undefined ? generalTablesOpt : [];
     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 === eventSyncStateTableName;
-          })) {
-      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_PUBLIC_SCHEMA\" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.");
-    }
-    var queries = makeInitializeTransaction(pgSchema, pgUser, generalTables, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
+    var cleanRun = cleanRunOpt !== undefined ? cleanRunOpt : false;
+    var queries = makeInitializeTransaction(pgSchema, pgUser, generalTables, entities, enums, cleanRun);
     await sql.begin(function (sql) {
           return queries.map(function (query) {
                       return sql.unsafe(query);
                     });
         });
   };
-  var loadEffectCaches = async function () {
-    var schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
-    return Belt_Array.keepMapU(schemaTableNames, (function (schemaTableName) {
-                  if (schemaTableName.table_name.startsWith("effect_cache_")) {
-                    return {
-                            name: schemaTableName.table_name,
-                            size: 0,
-                            table: undefined
-                          };
-                  }
-                  
-                }));
-  };
   var loadByIdsOrThrow = async function (ids, table, rowsSchema) {
     var 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})
+        ids.length !== 1 ? sql.unsafe(makeLoadByIdsSql(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeLoadByIdSql(pgSchema, table.tableName), ids, {prepare: true})
       );
     }
     catch (raw_exn){
@@ -352,81 +302,32 @@ function make(sql, pgSchema, pgUser) {
           };
     }
   };
-  var loadByFieldOrThrow = async function (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) {
-    var params;
-    try {
-      params = [S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema)];
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(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()
-          };
-    }
-    var 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);
-      throw {
-            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);
-      throw {
-            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);
   };
   return {
           isInitialized: isInitialized,
           initialize: initialize,
-          loadEffectCaches: loadEffectCaches,
           loadByIdsOrThrow: loadByIdsOrThrow,
-          loadByFieldOrThrow: loadByFieldOrThrow,
           setOrThrow: setOrThrow$1
         };
 }
 
 var maxItemsPerQuery = 500;
 
-exports.makeCreateIndexQuery = makeCreateIndexQuery;
-exports.makeCreateTableIndicesQuery = makeCreateTableIndicesQuery;
-exports.makeCreateTableQuery = makeCreateTableQuery;
+exports.makeCreateIndexSql = makeCreateIndexSql;
+exports.makeCreateTableIndicesSql = makeCreateTableIndicesSql;
+exports.makeCreateTableSql = makeCreateTableSql;
 exports.makeInitializeTransaction = makeInitializeTransaction;
-exports.makeLoadByIdQuery = makeLoadByIdQuery;
-exports.makeLoadByFieldQuery = makeLoadByFieldQuery;
-exports.makeLoadByIdsQuery = makeLoadByIdsQuery;
-exports.makeInsertUnnestSetQuery = makeInsertUnnestSetQuery;
-exports.makeInsertValuesSetQuery = makeInsertValuesSetQuery;
+exports.makeLoadByIdSql = makeLoadByIdSql;
+exports.makeLoadByIdsSql = makeLoadByIdsSql;
+exports.makeInsertUnnestSetSql = makeInsertUnnestSetSql;
+exports.makeInsertValuesSetSql = makeInsertValuesSetSql;
 exports.rawEventsTableName = rawEventsTableName;
-exports.eventSyncStateTableName = eventSyncStateTableName;
 exports.maxItemsPerQuery = maxItemsPerQuery;
 exports.makeTableBatchSetQuery = makeTableBatchSetQuery;
 exports.chunkArray = chunkArray;
-exports.removeInvalidUtf8InPlace = removeInvalidUtf8InPlace;
-exports.pgEncodingErrorSchema = pgEncodingErrorSchema;
-exports.PgEncodingError = PgEncodingError;
 exports.setQueryCache = setQueryCache;
 exports.setOrThrow = setOrThrow;
-exports.setEntityHistoryOrThrow = setEntityHistoryOrThrow;
-exports.makeSchemaTableNamesQuery = makeSchemaTableNamesQuery;
 exports.make = make;
-/* pgEncodingErrorSchema Not a pure module */
+/* setQueryCache Not a pure module */

package/src/Utils.res

@@ -301,23 +301,6 @@ module String = {
     str->Js.String2.slice(~from=0, ~to_=1)->Js.String.toUpperCase ++
       str->Js.String2.sliceToEnd(~from=1)
   }
-
-  /**
-`replaceAll(str, substr, newSubstr)` returns a new `string` which is
-identical to `str` except with all matching instances of `substr` replaced
-by `newSubstr`. `substr` is treated as a verbatim string to match, not a
-regular expression.
-See [`String.replaceAll`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll) on MDN.
-
-## Examples
-
-```rescript
-String.replaceAll("old old string", "old", "new") == "new new string"
-String.replaceAll("the cat and the dog", "the", "this") == "this cat and this dog"
-```
-*/
-  @send
-  external replaceAll: (string, string, string) => string = "replaceAll"
 }
 
 module Result = {

package/src/db/EntityHistory.res

@@ -148,12 +148,33 @@ type t<'entity> = {
   insertFn: (Postgres.sql, Js.Json.t, ~shouldCopyCurrentEntity: bool) => promise<unit>,
 }
 
+let insertRow = (
+  self: t<'entity>,
+  ~sql,
+  ~historyRow: historyRow<'entity>,
+  ~shouldCopyCurrentEntity,
+) => {
+  let row = historyRow->S.reverseConvertToJsonOrThrow(self.schema)
+  self.insertFn(sql, row, ~shouldCopyCurrentEntity)
+}
+
+let batchInsertRows = (self: t<'entity>, ~sql, ~rows: array<historyRow<'entity>>) => {
+  rows
+  ->Belt.Array.map(historyRow => {
+    let containsRollbackDiffChange =
+      historyRow.containsRollbackDiffChange->Belt.Option.getWithDefault(false)
+    let shouldCopyCurrentEntity = !containsRollbackDiffChange
+    self->insertRow(~sql, ~historyRow, ~shouldCopyCurrentEntity)
+  })
+  ->Promise.all
+  ->Promise.thenResolve(_ => ())
+}
+
 type entityInternal
 
 external castInternal: t<'entity> => t<entityInternal> = "%identity"
-external eval: string => 'a = "eval"
 
-let fromTable = (table: table, ~pgSchema, ~schema: S.t<'entity>): t<'entity> => {
+let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
   let entity_history_block_timestamp = "entity_history_block_timestamp"
   let entity_history_chain_id = "entity_history_chain_id"
   let entity_history_block_number = "entity_history_block_number"
@@ -214,10 +235,12 @@ let fromTable = (table: table, ~pgSchema, ~schema: S.t<'entity>): t<'entity> =>
   let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
 
   let originTableName = table.tableName
+  let originSchemaName = table.schemaName
   let historyTableName = originTableName ++ "_history"
   //ignore composite indices
   let table = mkTable(
     historyTableName,
+    ~schemaName=originSchemaName,
     ~fields=Belt.Array.concatMany([
       currentHistoryFields,
       previousHistoryFields,
@@ -228,8 +251,8 @@ let fromTable = (table: table, ~pgSchema, ~schema: S.t<'entity>): t<'entity> =>
 
   let insertFnName = `"insert_${table.tableName}"`
   let historyRowArg = "history_row"
-  let historyTablePath = `"${pgSchema}"."${historyTableName}"`
-  let originTablePath = `"${pgSchema}"."${originTableName}"`
+  let historyTablePath = `"${originSchemaName}"."${historyTableName}"`
+  let originTablePath = `"${originSchemaName}"."${originTableName}"`
 
   let previousHistoryFieldsAreNullStr =
     previousChangeFieldNames
@@ -312,7 +335,7 @@ let fromTable = (table: table, ~pgSchema, ~schema: S.t<'entity>): t<'entity> =>
     \${shouldCopyCurrentEntity});\``
 
   let insertFn: (Postgres.sql, Js.Json.t, ~shouldCopyCurrentEntity: bool) => promise<unit> =
-    insertFnString->eval
+    insertFnString->Table.PostgresInterop.eval
 
   let schema = makeHistoryRowSchema(schema)
 

package/src/db/EntityHistory.res.js

@@ -4,6 +4,7 @@
 var Table = require("./Table.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
 var variants = [
@@ -157,7 +158,22 @@ function makeHistoryRowSchema(entitySchema) {
               }));
 }
 
-function fromTable(table, pgSchema, schema) {
+function insertRow(self, sql, historyRow, shouldCopyCurrentEntity) {
+  var row = S$RescriptSchema.reverseConvertToJsonOrThrow(historyRow, self.schema);
+  return self.insertFn(sql, row, shouldCopyCurrentEntity);
+}
+
+function batchInsertRows(self, sql, rows) {
+  return Promise.all(Belt_Array.map(rows, (function (historyRow) {
+                      var containsRollbackDiffChange = Belt_Option.getWithDefault(historyRow.containsRollbackDiffChange, false);
+                      var shouldCopyCurrentEntity = !containsRollbackDiffChange;
+                      return insertRow(self, sql, historyRow, shouldCopyCurrentEntity);
+                    }))).then(function (param) {
+              
+            });
+}
+
+function fromTable(table, schema) {
   var currentChangeFieldNames = [
     "entity_history_block_timestamp",
     "entity_history_chain_id",
@@ -222,8 +238,9 @@ function fromTable(table, pgSchema, schema) {
           return Table.getFieldName(field);
         }));
   var originTableName = table.tableName;
+  var originSchemaName = table.schemaName;
   var historyTableName = originTableName + "_history";
-  var table$1 = Table.mkTable(historyTableName, undefined, Belt_Array.concatMany([
+  var table$1 = Table.mkTable(historyTableName, originSchemaName, undefined, Belt_Array.concatMany([
             currentHistoryFields,
             previousHistoryFields,
             dataFields,
@@ -234,8 +251,8 @@ function fromTable(table, pgSchema, schema) {
           ]));
   var insertFnName = "\"insert_" + table$1.tableName + "\"";
   var historyRowArg = "history_row";
-  var historyTablePath = "\"" + pgSchema + "\".\"" + historyTableName + "\"";
-  var originTablePath = "\"" + pgSchema + "\".\"" + originTableName + "\"";
+  var historyTablePath = "\"" + originSchemaName + "\".\"" + historyTableName + "\"";
+  var originTablePath = "\"" + originSchemaName + "\".\"" + originTableName + "\"";
   var previousHistoryFieldsAreNullStr = Belt_Array.map(previousChangeFieldNames, (function (fieldName) {
             return historyRowArg + "." + fieldName + " IS NULL";
           })).join(" OR ");
@@ -284,5 +301,7 @@ exports.entityIdOnlySchema = entityIdOnlySchema;
 exports.previousHistoryFieldsSchema = previousHistoryFieldsSchema;
 exports.currentHistoryFieldsSchema = currentHistoryFieldsSchema;
 exports.makeHistoryRowSchema = makeHistoryRowSchema;
+exports.insertRow = insertRow;
+exports.batchInsertRows = batchInsertRows;
 exports.fromTable = fromTable;
 /* schema Not a pure module */

package/src/db/Table.res

@@ -89,12 +89,14 @@ let getFieldType = (field: field) => {
 
 type table = {
   tableName: string,
+  schemaName: string,
   fields: array<fieldOrDerived>,
   compositeIndices: array<array<string>>,
 }
 
-let mkTable = (tableName, ~compositeIndices=[], ~fields) => {
+let mkTable = (tableName, ~schemaName, ~compositeIndices=[], ~fields) => {
   tableName,
+  schemaName,
   fields,
   compositeIndices,
 }
@@ -185,7 +187,7 @@ type sqlParams<'entity> = {
   hasArrayField: bool,
 }
 
-let toSqlParams = (table: table, ~schema, ~pgSchema) => {
+let toSqlParams = (table: table, ~schema) => {
   let quotedFieldNames = []
   let quotedNonPrimaryFieldNames = []
   let arrayFieldTypes = []
@@ -240,7 +242,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
           switch field {
           | Field(f) =>
             switch f.fieldType {
-            | Custom(fieldType) => `${(Text :> string)}[]::"${pgSchema}".${(fieldType :> string)}`
+            | Custom(fieldType) => `${(Text :> string)}[]::${(fieldType :> string)}`
             | Boolean => `${(Integer :> string)}[]::${(f.fieldType :> string)}`
             | fieldType => (fieldType :> string)
             }
@@ -297,3 +299,59 @@ let getCompositeIndices = (table): array<array<string>> => {
   ->getUnfilteredCompositeIndicesUnsafe
   ->Array.keep(ind => ind->Array.length > 1)
 }
+
+module PostgresInterop = {
+  type pgFn<'payload, 'return> = (Postgres.sql, 'payload) => promise<'return>
+  type batchSetFn<'a> = (Postgres.sql, array<'a>) => promise<unit>
+  external eval: string => 'a = "eval"
+
+  let makeBatchSetFnString = (table: table) => {
+    let fieldNamesInQuotes =
+      table->getNonDefaultFieldNames->Array.map(fieldName => `"${fieldName}"`)
+    `(sql, rows) => {
+      return sql\`
+        INSERT INTO "${table.schemaName}"."${table.tableName}"
+        \${sql(rows, ${fieldNamesInQuotes->Js.Array2.joinWith(", ")})}
+        ON CONFLICT(${table->getPrimaryKeyFieldNames->Js.Array2.joinWith(", ")}) DO UPDATE
+        SET
+        ${fieldNamesInQuotes
+      ->Array.map(fieldNameInQuotes => `${fieldNameInQuotes} = EXCLUDED.${fieldNameInQuotes}`)
+      ->Js.Array2.joinWith(", ")};\`
+    }`
+  }
+
+  let chunkBatchQuery = (
+    sql,
+    entityDataArray: array<'entity>,
+    queryToExecute: pgFn<array<'entity>, 'return>,
+    ~maxItemsPerQuery=500,
+  ): promise<array<'return>> => {
+    let responses = []
+    let i = ref(0)
+    let shouldContinue = () => i.contents < entityDataArray->Array.length
+    // Split entityDataArray into chunks of maxItemsPerQuery
+    while shouldContinue() {
+      let chunk =
+        entityDataArray->Js.Array2.slice(~start=i.contents, ~end_=i.contents + maxItemsPerQuery)
+      let response = queryToExecute(sql, chunk)
+      responses->Js.Array2.push(response)->ignore
+      i := i.contents + maxItemsPerQuery
+    }
+    Promise.all(responses)
+  }
+
+  let makeBatchSetFn = (~table, ~schema: S.t<'a>): batchSetFn<'a> => {
+    let batchSetFn: pgFn<array<Js.Json.t>, unit> = table->makeBatchSetFnString->eval
+    let parseOrThrow = S.compile(
+      S.array(schema),
+      ~input=Value,
+      ~output=Json,
+      ~mode=Sync,
+      ~typeValidation=true,
+    )
+    async (sql, rows) => {
+      let rowsJson = rows->parseOrThrow->(Utils.magic: Js.Json.t => array<Js.Json.t>)
+      let _res = await chunkBatchQuery(sql, rowsJson, batchSetFn)
+    }
+  }
+}