Just clean up, no changes

codegenerator/cli/npm/envio/src/Persistence.res

@@ -47,7 +47,6 @@ type t = {
   mutable storageStatus: storageStatus,
   storage: storage,
   onStorageInitialize: option<unit => promise<unit>>,
-  cacheStorage: storage,
 }
 
 let entityHistoryActionEnumConfig: Internal.enumConfig<EntityHistory.RowAction.t> = {
@@ -64,7 +63,6 @@ let make = (
   ~allEnums,
   ~staticTables,
   ~storage,
-  ~cacheStorage,
   ~onStorageInitialize=?,
 ) => {
   let allEntities = userEntities->Js.Array2.concat([dcRegistryEntityConfig])
@@ -78,7 +76,6 @@ let make = (
     storageStatus: Unknown,
     storage,
     onStorageInitialize,
-    cacheStorage,
   }
 }
 

codegenerator/cli/npm/envio/src/db/EntityHistory.res

@@ -173,8 +173,9 @@ let batchInsertRows = (self: t<'entity>, ~sql, ~rows: array<historyRow<'entity>>
 type entityInternal
 
 external castInternal: t<'entity> => t<entityInternal> = "%identity"
+external eval: string => 'a = "eval"
 
-let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
+let fromTable = (table: table, ~pgSchema, ~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"
@@ -235,12 +236,10 @@ let fromTable = (table: table, ~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,
@@ -251,8 +250,8 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let insertFnName = `"insert_${table.tableName}"`
   let historyRowArg = "history_row"
-  let historyTablePath = `"${originSchemaName}"."${historyTableName}"`
-  let originTablePath = `"${originSchemaName}"."${originTableName}"`
+  let historyTablePath = `"${pgSchema}"."${historyTableName}"`
+  let originTablePath = `"${pgSchema}"."${originTableName}"`
 
   let previousHistoryFieldsAreNullStr =
     previousChangeFieldNames
@@ -335,7 +334,7 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
     \${shouldCopyCurrentEntity});\``
 
   let insertFn: (Postgres.sql, Js.Json.t, ~shouldCopyCurrentEntity: bool) => promise<unit> =
-    insertFnString->Table.PostgresInterop.eval
+    insertFnString->eval
 
   let schema = makeHistoryRowSchema(schema)
 

codegenerator/cli/npm/envio/src/db/Table.res

@@ -89,14 +89,12 @@ let getFieldType = (field: field) => {
 
 type table = {
   tableName: string,
-  schemaName: string,
   fields: array<fieldOrDerived>,
   compositeIndices: array<array<string>>,
 }
 
-let mkTable = (tableName, ~schemaName, ~compositeIndices=[], ~fields) => {
+let mkTable = (tableName, ~compositeIndices=[], ~fields) => {
   tableName,
-  schemaName,
   fields,
   compositeIndices,
 }
@@ -299,59 +297,3 @@ 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)
-    }
-  }
-}

codegenerator/cli/templates/dynamic/codegen/src/TestHelpers_MockDb.res.hbs

@@ -263,7 +263,7 @@ let getEntityOperations = (mockDb: t, ~entityConfig: Internal.entityConfig): ent
 }
 
 let makeLoadEntitiesByIds = (mockDb: t) => {
-  (ids, ~entityConfig, ~logger as _=?) => {
+  (ids, ~entityConfig) => {
     let operations = mockDb->getEntityOperations(~entityConfig)
     ids->Array.keepMap(id => operations.get(id))->Promise.resolve
   }

codegenerator/cli/templates/dynamic/codegen/src/db/Entities.res.hbs

@@ -67,7 +67,6 @@ module {{entity.name.capitalized}} = {
 
   let table = mkTable(
     (name :> string),
-    ~schemaName=Env.Db.publicSchema,
     ~fields=[
   {{#each entity.postgres_fields as | pg_field |}}
       mkField(
@@ -105,7 +104,7 @@ module {{entity.name.capitalized}} = {
   {{/if}}
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema)
+  let entityHistory = table->EntityHistory.fromTable(~pgSchema=Env.Db.publicSchema, ~schema)
 
   external castToInternal: t => Internal.entity = "%identity"
 }

codegenerator/cli/templates/static/codegen/src/Config.res

@@ -87,7 +87,6 @@ let codegenPersistence = Persistence.make(
   )->Entities.entityModToInternal,
   ~allEnums=Enums.allEnums,
   ~storage=PgStorage.make(~sql=Db.sql, ~pgSchema=storagePgSchema, ~pgUser=Env.Db.user),
-  ~cacheStorage=PgStorage.make(~sql=Db.sql, ~pgSchema=Env.Db.cacheSchema, ~pgUser=Env.Db.user),
   ~onStorageInitialize=() => {
     Hasura.trackDatabase(
       ~endpoint=Env.Hasura.graphqlEndpoint,

codegenerator/cli/templates/static/codegen/src/Env.res

@@ -110,7 +110,6 @@ module Db = {
   let password = envSafe->EnvSafe.get("ENVIO_POSTGRES_PASSWORD", S.string, ~devFallback="testing")
   let database = envSafe->EnvSafe.get("ENVIO_PG_DATABASE", S.string, ~devFallback="envio-dev")
   let publicSchema = envSafe->EnvSafe.get("ENVIO_PG_PUBLIC_SCHEMA", S.string, ~fallback="public")
-  let cacheSchema = envSafe->EnvSafe.get("ENVIO_PG_CACHE_SCHEMA", S.string, ~fallback="envio_cache")
   let ssl = envSafe->EnvSafe.get(
     "ENVIO_PG_SSL_MODE",
     Postgres.sslOptionsSchema,

codegenerator/cli/templates/static/codegen/src/LoadLayer.res

@@ -7,7 +7,6 @@ type t = {
   loadEntitiesByIds: (
     array<Types.id>,
     ~entityConfig: Internal.entityConfig,
-    ~logger: Pino.t=?,
   ) => promise<array<Internal.entity>>,
   loadEntitiesByField: (
     ~operator: TableIndices.Operator.t,
@@ -33,7 +32,7 @@ let makeWithDbConnection = (~persistence=Config.codegenPersistence) => {
   let storage = Persistence.getInitializedStorageOrThrow(persistence)
   {
     loadManager: LoadManager.make(),
-    loadEntitiesByIds: (ids, ~entityConfig, ~logger as _=?) =>
+    loadEntitiesByIds: (ids, ~entityConfig) =>
       storage.loadByIdsOrThrow(
         ~table=entityConfig.table,
         ~rowsSchema=entityConfig.rowsSchema,
@@ -55,13 +54,10 @@ let loadById = (
   let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
 
   let load = async idsToLoad => {
-    // Since makeLoader prevents registerign entities already existing in the inMemoryStore,
+    // Since LoadManager.call prevents registerign entities already existing in the inMemoryStore,
     // we can be sure that we load only the new ones.
     let dbEntities = try {
-      await idsToLoad->loadLayer.loadEntitiesByIds(
-        ~entityConfig,
-        ~logger=eventItem->Logging.getEventLogger,
-      )
+      await idsToLoad->loadLayer.loadEntitiesByIds(~entityConfig)
     } catch {
     | Persistence.StorageError({message, reason}) =>
       reason->ErrorHandling.mkLogAndRaise(~logger=eventItem->Logging.getEventLogger, ~msg=message)

codegenerator/cli/templates/static/codegen/src/LoadLayer.resi

@@ -6,7 +6,6 @@ let make: (
   ~loadEntitiesByIds: (
     array<Types.id>,
     ~entityConfig: Internal.entityConfig,
-    ~logger: Pino.t=?,
   ) => promise<array<Internal.entity>>,
   ~loadEntitiesByField: (
     ~operator: TableIndices.Operator.t,

codegenerator/cli/templates/static/codegen/src/db/TablesStatic.res

@@ -5,8 +5,6 @@ let isPrimaryKey = true
 let isNullable = true
 let isIndex = true
 
-let publicSchema = Env.Db.publicSchema
-
 module EventSyncState = {
   //Used unsafely in DbFunctions.res so just enforcing the naming here
   let blockTimestampFieldName = "block_timestamp"
@@ -24,7 +22,6 @@ module EventSyncState = {
 
   let table = mkTable(
     "event_sync_state",
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("chain_id", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
       mkField(blockNumberFieldName, Integer, ~fieldSchema=S.int),
@@ -42,7 +39,7 @@ module EventSyncState = {
 
   //We need to update values here not delet the rows, since restarting without a row
   //has a different behaviour to restarting with an initialised row with zero values
-  let resetCurrentCurrentSyncStateQuery = `UPDATE ${table.schemaName}.${table.tableName}
+  let resetCurrentCurrentSyncStateQuery = `UPDATE "${Env.Db.publicSchema}"."${table.tableName}"
     SET ${blockNumberFieldName} = 0, 
         ${logIndexFieldName} = 0, 
         ${blockTimestampFieldName} = 0, 
@@ -67,7 +64,6 @@ module ChainMetadata = {
 
   let table = mkTable(
     "chain_metadata",
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("chain_id", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
       mkField("start_block", Integer, ~fieldSchema=S.int),
@@ -103,7 +99,6 @@ module PersistedState = {
 
   let table = mkTable(
     "persisted_state",
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("id", Serial, ~fieldSchema=S.int, ~isPrimaryKey),
       mkField("envio_version", Text, ~fieldSchema=S.string),
@@ -125,7 +120,6 @@ module EndOfBlockRangeScannedData = {
 
   let table = mkTable(
     "end_of_block_range_scanned_data",
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("chain_id", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
       mkField("block_number", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
@@ -168,7 +162,6 @@ module RawEvents = {
 
   let table = mkTable(
     PgStorage.rawEventsTableName,
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("chain_id", Integer, ~fieldSchema=S.int),
       mkField("event_id", Numeric, ~fieldSchema=S.bigint),
@@ -231,7 +224,6 @@ module DynamicContractRegistry = {
 
   let table = mkTable(
     "dynamic_contract_registry",
-    ~schemaName=publicSchema,
     ~fields=[
       mkField("id", Text, ~isPrimaryKey, ~fieldSchema=S.string),
       mkField("chain_id", Integer, ~fieldSchema=S.int),
@@ -250,5 +242,5 @@ module DynamicContractRegistry = {
     ],
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema)
+  let entityHistory = table->EntityHistory.fromTable(~pgSchema=Env.Db.publicSchema, ~schema)
 }

scenarios/test_codegen/test/helpers/Mock.res

@@ -54,7 +54,7 @@ module LoadLayer = {
     let loadEntitiesByIdsCalls = []
     let loadEntitiesByFieldCalls = []
     let loadLayer = LoadLayer.make(
-      ~loadEntitiesByIds=async (entityIds, ~entityConfig, ~logger as _=?) => {
+      ~loadEntitiesByIds=async (entityIds, ~entityConfig) => {
         loadEntitiesByIdsCalls
         ->Js.Array2.push({
           entityIds,

scenarios/test_codegen/test/lib_tests/EntityHistory_test.res

@@ -45,26 +45,29 @@ module TestEntity = {
   let rowsSchema = S.array(schema)
   let table = Table.mkTable(
     "TestEntity",
-    ~schemaName="public",
     ~fields=[
       Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
       Table.mkField("fieldA", Integer, ~fieldSchema=S.int),
       Table.mkField("fieldB", Text, ~fieldSchema=S.null(S.string), ~isNullable=true),
     ],
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema)
+  let entityHistory = table->EntityHistory.fromTable(~pgSchema="public", ~schema)
 
   external castToInternal: t => Internal.entity = "%identity"
 }
 
 type testEntityHistory = EntityHistory.historyRow<TestEntity.t>
 let testEntityHistorySchema = EntityHistory.makeHistoryRowSchema(TestEntity.schema)
 
-let batchSetMockEntity = Table.PostgresInterop.makeBatchSetFn(
-  ~table=TestEntity.table,
-  ~schema=TestEntity.schema,
-)
+let batchSetMockEntity = (sql, items) =>
+  PgStorage.setOrThrow(
+    sql,
+    ~items,
+    ~pgSchema="public",
+    ~table=TestEntity.table,
+    ~itemSchema=TestEntity.schema,
+  )
 
 let getAllMockEntity = sql =>
   sql

scenarios/test_codegen/test/lib_tests/Persistence_test.res

@@ -69,7 +69,6 @@ describe("Test Persistence layer init", () => {
       )->Entities.entityModToInternal,
       ~allEnums=[],
       ~storage=storageMock.storage,
-      ~cacheStorage=makeStorageMock().storage,
     )
 
     Assert.deepEqual(
@@ -191,7 +190,6 @@ describe("Test Persistence layer init", () => {
       )->Entities.entityModToInternal,
       ~allEnums=[],
       ~storage=storageMock.storage,
-      ~cacheStorage=makeStorageMock().storage,
     )
 
     let p = persistence->Persistence.init
@@ -228,7 +226,6 @@ describe("Test Persistence layer init", () => {
       )->Entities.entityModToInternal,
       ~allEnums=[],
       ~storage=storageMock.storage,
-      ~cacheStorage=makeStorageMock().storage,
     )
 
     let _ = persistence->Persistence.init(~skipIsInitializedCheck=true)