envio 2.32.3 → 3.0.0-alpha.0

package/src/InMemoryTable.res

@@ -39,7 +39,8 @@ module Entity = {
   type indexFieldNameToIndices = t<TableIndices.Index.t, indicesSerializedToValue>
 
   type entityWithIndices<'entity> = {
-    entityRow: Internal.inMemoryStoreRowEntity<'entity>,
+    latest: option<'entity>,
+    status: Internal.inMemoryStoreEntityStatus<'entity>,
     entityIndices: Utils.Set.t<TableIndices.Index.t>,
   }
   type t<'entity> = {
@@ -147,18 +148,20 @@ module Entity = {
     //or if allowOverWriteEntity is true (used for mockDb in test helpers)
     if shouldWriteEntity {
       let entityIndices = Utils.Set.make()
-      let initialStoreRow: Internal.inMemoryStoreRowEntity<'entity> = switch entity {
+      switch entity {
       | Some(entity) =>
         //update table indices in the case where there
         //is an already set entity
         inMemTable->updateIndices(~entity, ~entityIndices)
-        InitialReadFromDb(AlreadySet(entity))
-
-      | None => InitialReadFromDb(NotSet)
+      | None => ()
       }
       inMemTable.table.dict->Js.Dict.set(
         key->inMemTable.table.hash,
-        {entityRow: initialStoreRow, entityIndices},
+        {
+          latest: entity,
+          status: Loaded,
+          entityIndices,
+        },
       )
     }
   }
@@ -166,56 +169,64 @@ module Entity = {
   let setRow = set
   let set = (
     inMemTable: t<'entity>,
-    entityUpdate: EntityHistory.entityUpdate<'entity>,
+    change: Change.t<'entity>,
     ~shouldSaveHistory,
     ~containsRollbackDiffChange=false,
   ) => {
     //New entity row with only the latest update
     @inline
-    let newEntityRow = () => Internal.Updated({
-      latest: entityUpdate,
-      history: shouldSaveHistory ? [entityUpdate] : [],
+    let newStatus = () => Internal.Updated({
+      latestChange: change,
+      history: shouldSaveHistory
+        ? [change]
+        : Utils.Array.immutableEmpty->(Utils.magic: array<unknown> => array<Change.t<'entity>>),
       containsRollbackDiffChange,
     })
+    let latest = switch change {
+    | Set({entity}) => Some(entity)
+    | Delete(_) => None
+    }
 
-    let {entityRow, entityIndices} = switch inMemTable.table->get(entityUpdate.entityId) {
-    | None => {entityRow: newEntityRow(), entityIndices: Utils.Set.make()}
-    | Some({entityRow: InitialReadFromDb(_), entityIndices}) => {
-        entityRow: newEntityRow(),
+    let updatedEntityRecord = switch inMemTable.table->get(change->Change.getEntityId) {
+    | None => {latest, status: newStatus(), entityIndices: Utils.Set.make()}
+    | Some({status: Loaded, entityIndices}) => {
+        latest,
+        status: newStatus(),
         entityIndices,
       }
-    | Some({entityRow: Updated(previous_values), entityIndices}) =>
-      let entityRow = Internal.Updated({
-        latest: entityUpdate,
+    | Some({status: Updated(previous_values), entityIndices}) =>
+      let newStatus = Internal.Updated({
+        latestChange: change,
         history: switch shouldSaveHistory {
         // This prevents two db actions in the same event on the same entity from being recorded to the history table.
-        | true if previous_values.latest.checkpointId === entityUpdate.checkpointId =>
+        | true
+          if previous_values.latestChange->Change.getCheckpointId ===
+            change->Change.getCheckpointId =>
           previous_values.history->Utils.Array.setIndexImmutable(
             previous_values.history->Array.length - 1,
-            entityUpdate,
+            change,
           )
-        | true => [...previous_values.history, entityUpdate]
+        | true => [...previous_values.history, change]
         | false => previous_values.history
         },
         containsRollbackDiffChange: previous_values.containsRollbackDiffChange,
       })
-      {entityRow, entityIndices}
+      {latest, status: newStatus, entityIndices}
     }
 
-    switch entityUpdate.entityUpdateAction {
-    | Set(entity) => inMemTable->updateIndices(~entity, ~entityIndices)
-    | Delete => inMemTable->deleteEntityFromIndices(~entityId=entityUpdate.entityId, ~entityIndices)
+    switch change {
+    | Set({entity}) =>
+      inMemTable->updateIndices(~entity, ~entityIndices=updatedEntityRecord.entityIndices)
+    | Delete({entityId}) =>
+      inMemTable->deleteEntityFromIndices(
+        ~entityId,
+        ~entityIndices=updatedEntityRecord.entityIndices,
+      )
     }
-    inMemTable.table->setRow(entityUpdate.entityId, {entityRow, entityIndices})
+    inMemTable.table->setRow(change->Change.getEntityId, updatedEntityRecord)
   }
 
-  let rowToEntity = row =>
-    switch row.entityRow {
-    | Internal.Updated({latest: {entityUpdateAction: Set(entity)}}) => Some(entity)
-    | Updated({latest: {entityUpdateAction: Delete}}) => None
-    | InitialReadFromDb(AlreadySet(entity)) => Some(entity)
-    | InitialReadFromDb(NotSet) => None
-    }
+  let rowToEntity = row => row.latest
 
   let getRow = get
 
@@ -330,10 +341,15 @@ module Entity = {
       }
     }
 
-  let rows = (inMemTable: t<'entity>) => {
+  let updates = (inMemTable: t<'entity>) => {
     inMemTable.table
     ->values
-    ->Array.map(v => v.entityRow)
+    ->Array.keepMapU(v =>
+      switch v.status {
+      | Updated(update) => Some(update)
+      | Loaded => None
+      }
+    )
   }
 
   let values = (inMemTable: t<'entity>) => {
@@ -353,4 +369,3 @@ module Entity = {
     },
   }
 }
-

package/src/{InMemoryTable.res.js → InMemoryTable.res.mjs}

@@ -1,16 +1,15 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
 
-var Utils = require("./Utils.res.js");
-var Js_exn = require("rescript/lib/js/js_exn.js");
-var Lodash = require("./bindings/Lodash.res.js");
-var Js_dict = require("rescript/lib/js/js_dict.js");
-var Belt_Array = require("rescript/lib/js/belt_Array.js");
-var Belt_Option = require("rescript/lib/js/belt_Option.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var TableIndices = require("./TableIndices.res.js");
-var ErrorHandling = require("./ErrorHandling.res.js");
-var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Lodash from "./bindings/Lodash.res.mjs";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as TableIndices from "./TableIndices.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 
 function make(hash) {
   return {
@@ -147,114 +146,77 @@ function initValue(inMemTable, key, entity, allowOverWriteEntityOpt) {
     return ;
   }
   var entityIndices = new Set();
-  var initialStoreRow;
   if (entity !== undefined) {
-    var entity$1 = Caml_option.valFromOption(entity);
-    updateIndices(inMemTable, entity$1, entityIndices);
-    initialStoreRow = {
-      TAG: "InitialReadFromDb",
-      _0: {
-        TAG: "AlreadySet",
-        _0: entity$1
-      }
-    };
-  } else {
-    initialStoreRow = {
-      TAG: "InitialReadFromDb",
-      _0: "NotSet"
-    };
+    updateIndices(inMemTable, Caml_option.valFromOption(entity), entityIndices);
   }
   inMemTable.table.dict[inMemTable.table.hash(key)] = {
-    entityRow: initialStoreRow,
+    latest: entity,
+    status: "Loaded",
     entityIndices: entityIndices
   };
 }
 
-function set$1(inMemTable, entityUpdate, shouldSaveHistory, containsRollbackDiffChangeOpt) {
+function set$1(inMemTable, change, shouldSaveHistory, containsRollbackDiffChangeOpt) {
   var containsRollbackDiffChange = containsRollbackDiffChangeOpt !== undefined ? containsRollbackDiffChangeOpt : false;
-  var match = get(inMemTable.table, entityUpdate.entityId);
-  var match$1;
+  var latest;
+  latest = change.type === "SET" ? Caml_option.some(change.entity) : undefined;
+  var match = get(inMemTable.table, change.entityId);
+  var updatedEntityRecord;
   if (match !== undefined) {
-    var previous_values = match.entityRow;
-    if (previous_values.TAG === "Updated") {
-      var previous_values$1 = previous_values._0;
-      var entityRow = {
-        TAG: "Updated",
-        _0: {
-          latest: entityUpdate,
-          history: shouldSaveHistory ? (
-              previous_values$1.latest.checkpointId === entityUpdate.checkpointId ? Utils.$$Array.setIndexImmutable(previous_values$1.history, previous_values$1.history.length - 1 | 0, entityUpdate) : Belt_Array.concatMany([
-                      previous_values$1.history,
-                      [entityUpdate]
-                    ])
-            ) : previous_values$1.history,
-          containsRollbackDiffChange: previous_values$1.containsRollbackDiffChange
-        }
-      };
-      match$1 = {
-        entityRow: entityRow,
+    var previous_values = match.status;
+    if (typeof previous_values !== "object") {
+      updatedEntityRecord = {
+        latest: latest,
+        status: {
+          latestChange: change,
+          history: shouldSaveHistory ? [change] : Utils.$$Array.immutableEmpty,
+          containsRollbackDiffChange: containsRollbackDiffChange
+        },
         entityIndices: match.entityIndices
       };
     } else {
-      match$1 = {
-        entityRow: {
-          TAG: "Updated",
-          _0: {
-            latest: entityUpdate,
-            history: shouldSaveHistory ? [entityUpdate] : [],
-            containsRollbackDiffChange: containsRollbackDiffChange
-          }
-        },
+      var newStatus = {
+        latestChange: change,
+        history: shouldSaveHistory ? (
+            previous_values.latestChange.checkpointId === change.checkpointId ? Utils.$$Array.setIndexImmutable(previous_values.history, previous_values.history.length - 1 | 0, change) : Belt_Array.concatMany([
+                    previous_values.history,
+                    [change]
+                  ])
+          ) : previous_values.history,
+        containsRollbackDiffChange: previous_values.containsRollbackDiffChange
+      };
+      updatedEntityRecord = {
+        latest: latest,
+        status: newStatus,
         entityIndices: match.entityIndices
       };
     }
   } else {
-    match$1 = {
-      entityRow: {
-        TAG: "Updated",
-        _0: {
-          latest: entityUpdate,
-          history: shouldSaveHistory ? [entityUpdate] : [],
-          containsRollbackDiffChange: containsRollbackDiffChange
-        }
+    updatedEntityRecord = {
+      latest: latest,
+      status: {
+        latestChange: change,
+        history: shouldSaveHistory ? [change] : Utils.$$Array.immutableEmpty,
+        containsRollbackDiffChange: containsRollbackDiffChange
       },
       entityIndices: new Set()
     };
   }
-  var entityIndices = match$1.entityIndices;
-  var entity = entityUpdate.entityUpdateAction;
-  if (typeof entity !== "object") {
-    deleteEntityFromIndices(inMemTable, entityUpdate.entityId, entityIndices);
+  if (change.type === "SET") {
+    updateIndices(inMemTable, change.entity, updatedEntityRecord.entityIndices);
   } else {
-    updateIndices(inMemTable, entity._0, entityIndices);
+    deleteEntityFromIndices(inMemTable, change.entityId, updatedEntityRecord.entityIndices);
   }
-  set(inMemTable.table, entityUpdate.entityId, {
-        entityRow: match$1.entityRow,
-        entityIndices: entityIndices
-      });
+  set(inMemTable.table, change.entityId, updatedEntityRecord);
 }
 
 function rowToEntity(row) {
-  var match = row.entityRow;
-  if (match.TAG === "Updated") {
-    var entity = match._0.latest.entityUpdateAction;
-    if (typeof entity !== "object") {
-      return ;
-    } else {
-      return Caml_option.some(entity._0);
-    }
-  }
-  var entity$1 = match._0;
-  if (typeof entity$1 !== "object") {
-    return ;
-  } else {
-    return Caml_option.some(entity$1._0);
-  }
+  return row.latest;
 }
 
 function getUnsafe(inMemTable) {
   return function (key) {
-    return rowToEntity(inMemTable.table.dict[key]);
+    return inMemTable.table.dict[key].latest;
   };
 }
 
@@ -295,7 +257,7 @@ function addEmptyIndex(inMemTable, index) {
   var fieldName = TableIndices.Index.getFieldName(index);
   var relatedEntityIds = new Set();
   Belt_Array.forEach(Js_dict.values(inMemTable.table.dict), (function (row) {
-          var entity = rowToEntity(row);
+          var entity = row.latest;
           if (entity === undefined) {
             return ;
           }
@@ -340,9 +302,14 @@ function addIdToIndex(inMemTable, index, entityId) {
   }
 }
 
-function rows(inMemTable) {
-  return Belt_Array.map(Js_dict.values(inMemTable.table.dict), (function (v) {
-                return v.entityRow;
+function updates(inMemTable) {
+  return Belt_Array.keepMapU(Js_dict.values(inMemTable.table.dict), (function (v) {
+                var update = v.status;
+                if (typeof update !== "object") {
+                  return ;
+                } else {
+                  return update;
+                }
               }));
 }
 
@@ -384,18 +351,20 @@ var Entity = {
   getUnsafeOnIndex: getUnsafeOnIndex,
   addEmptyIndex: addEmptyIndex,
   addIdToIndex: addIdToIndex,
-  rows: rows,
+  updates: updates,
   values: values$1,
   clone: clone$1
 };
 
-exports.make = make;
-exports.set = set;
-exports.setByHash = setByHash;
-exports.hasByHash = hasByHash;
-exports.getUnsafeByHash = getUnsafeByHash;
-exports.get = get;
-exports.values = values;
-exports.clone = clone;
-exports.Entity = Entity;
+export {
+  make ,
+  set ,
+  setByHash ,
+  hasByHash ,
+  getUnsafeByHash ,
+  get ,
+  values ,
+  clone ,
+  Entity ,
+}
 /* Utils Not a pure module */

package/src/Internal.gen.ts

@@ -7,7 +7,7 @@ import type {GenericContractRegister as $$genericContractRegister} from './Types
 
 import type {Invalid as $$noEventFilters} from './Types.ts';
 
-import type {t as Address_t} from './Address.gen';
+import type {t as Address_t} from './Address.gen.js';
 
 export type genericEvent<params,block,transaction> = {
   readonly params: params; 
@@ -42,8 +42,6 @@ export type entityHandlerContext<entity> = {
   readonly deleteUnsafe: (_1:string) => void
 };
 
-export type chainInfo = { readonly isReady: boolean };
-
 export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly loader: loader; 
   readonly handler: handler; 
@@ -53,8 +51,6 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly preRegisterDynamicContracts?: boolean
 };
 
-export type blockEvent = { readonly number: number; readonly chainId: number };
-
 export type eventOptions<eventFilters> = {
   readonly wildcard?: boolean; 
   readonly eventFilters?: eventFilters; 

package/src/Internal.res

@@ -54,11 +54,11 @@ type entityHandlerContext<'entity> = {
   deleteUnsafe: string => unit,
 }
 
-@genType
 type chainInfo = {
+  id: int,
   // true when the chain has completed initial sync and is processing live events
   // false during historical synchronization
-  isReady: bool,
+  isLive: bool,
 }
 
 type chains = dict<chainInfo>
@@ -67,6 +67,7 @@ type loaderReturn
 type handlerContext = private {
   isPreload: bool,
   chains: chains,
+  chain: chainInfo,
 }
 type handlerArgs = {
   event: event,
@@ -169,11 +170,8 @@ type eventItem = private {
   event: event,
 }
 
-@genType
-type blockEvent = {
-  number: int,
-  chainId: int,
-}
+// Opaque type to support both EVM and Fuel platforms
+type blockEvent
 
 type onBlockArgs = {
   block: blockEvent,
@@ -212,6 +210,12 @@ external getItemBlockNumber: item => int = "blockNumber"
 @get
 external getItemLogIndex: item => int = "logIndex"
 
+let getItemChainId = item =>
+  switch item {
+  | Event({chain}) => chain->ChainMap.Chain.toChainId
+  | Block({onBlockConfig: {chainId}}) => chainId
+  }
+
 @get
 external getItemDcs: item => option<dcs> = "dcs"
 @set
@@ -249,36 +253,22 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
+type clickHouseSetUpdatesCache = {
+  tableName: string,
+  convertOrThrow: Change.t<entity> => Js.Json.t,
+}
 type genericEntityConfig<'entity> = {
   name: string,
   index: int,
   schema: S.t<'entity>,
   rowsSchema: S.t<array<'entity>>,
   table: Table.table,
-  entityHistory: EntityHistory.t<'entity>,
+  mutable clickHouseSetUpdatesCache?: clickHouseSetUpdatesCache,
+  mutable pgEntityHistoryCache?: EntityHistory.pgEntityHistory<'entity>,
 }
 type entityConfig = genericEntityConfig<entity>
 external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"
 
-type enum
-type enumConfig<'enum> = {
-  name: string,
-  variants: array<'enum>,
-  schema: S.t<'enum>,
-  default: 'enum,
-}
-external fromGenericEnumConfig: enumConfig<'enum> => enumConfig<enum> = "%identity"
-
-let makeEnumConfig = (~name, ~variants) => {
-  name,
-  variants,
-  schema: S.enum(variants),
-  default: switch variants->Belt.Array.get(0) {
-  | Some(v) => v
-  | None => Js.Exn.raiseError("No variants defined for enum " ++ name)
-  },
-}
-
 type effectInput
 type effectOutput
 type effectContext = private {mutable cache: bool}
@@ -322,8 +312,8 @@ let makeCacheTable = (~effectName) => {
   Table.mkTable(
     cacheTablePrefix ++ effectName,
     ~fields=[
-      Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-      Table.mkField("output", JsonB, ~fieldSchema=cacheOutputSchema, ~isNullable=true),
+      Table.mkField("id", String, ~fieldSchema=S.string, ~isPrimaryKey=true),
+      Table.mkField("output", Json, ~fieldSchema=cacheOutputSchema, ~isNullable=true),
     ],
   )
 }
@@ -331,9 +321,11 @@ let makeCacheTable = (~effectName) => {
 @genType.import(("./Types.ts", "Invalid"))
 type noEventFilters
 
+type checkpointId = float
+
 type reorgCheckpoint = {
   @as("id")
-  checkpointId: int,
+  checkpointId: float,
   @as("chain_id")
   chainId: int,
   @as("block_number")
@@ -342,13 +334,9 @@ type reorgCheckpoint = {
   blockHash: string,
 }
 
-type entityValueAtStartOfBatch<'entityType> =
-  | NotSet // The entity isn't in the DB yet
-  | AlreadySet('entityType)
-
-type updatedValue<'entityType> = {
-  latest: EntityHistory.entityUpdate<'entityType>,
-  history: array<EntityHistory.entityUpdate<'entityType>>,
+type inMemoryStoreEntityUpdate<'entity> = {
+  latestChange: Change.t<'entity>,
+  history: array<Change.t<'entity>>,
   // In the event of a rollback, some entity updates may have been
   // been affected by a rollback diff. If there was no rollback diff
   // this will always be false.
@@ -359,6 +347,7 @@ type updatedValue<'entityType> = {
   containsRollbackDiffChange: bool,
 }
 
-type inMemoryStoreRowEntity<'entityType> =
-  | Updated(updatedValue<'entityType>)
-  | InitialReadFromDb(entityValueAtStartOfBatch<'entityType>) // This means there is no change from the db.
+@unboxed
+type inMemoryStoreEntityStatus<'entity> =
+  | Updated(inMemoryStoreEntityUpdate<'entity>)
+  | Loaded // This means there is no change from the db.

package/src/Internal.res.mjs

@@ -0,0 +1,58 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./db/Table.res.mjs";
+import * as $$BigInt from "./bindings/BigInt.res.mjs";
+import * as Address from "./Address.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function getItemChainId(item) {
+  if (item.kind === 0) {
+    return item.chain;
+  } else {
+    return item.onBlockConfig.chainId;
+  }
+}
+
+var fuelSupplyParamsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              subId: s.m(S$RescriptSchema.string),
+              amount: s.m($$BigInt.schema)
+            };
+    });
+
+var fuelTransferParamsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              to: s.m(Address.schema),
+              assetId: s.m(S$RescriptSchema.string),
+              amount: s.m($$BigInt.schema)
+            };
+    });
+
+var cacheTablePrefix = "envio_effect_";
+
+var cacheOutputSchema = S$RescriptSchema.json(false);
+
+var effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(function (s) {
+          return {
+                  id: s.m(S$RescriptSchema.string),
+                  output: s.m(cacheOutputSchema)
+                };
+        }));
+
+function makeCacheTable(effectName) {
+  return Table.mkTable(cacheTablePrefix + effectName, undefined, [
+              Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
+              Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
+            ]);
+}
+
+export {
+  getItemChainId ,
+  fuelSupplyParamsSchema ,
+  fuelTransferParamsSchema ,
+  cacheTablePrefix ,
+  cacheOutputSchema ,
+  effectCacheItemRowsSchema ,
+  makeCacheTable ,
+}
+/* fuelSupplyParamsSchema Not a pure module */

package/src/{LazyLoader.res.js → LazyLoader.res.mjs}

@@ -1,12 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
 
-var Utils = require("./Utils.res.js");
-var JsSdsl = require("js-sdsl");
-var Belt_Option = require("rescript/lib/js/belt_Option.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
-var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+import * as Utils from "./Utils.res.mjs";
+import * as JsSdsl from "js-sdsl";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 
 var LoaderTimeout = /* @__PURE__ */Caml_exceptions.create("LazyLoader.LoaderTimeout");
 
@@ -108,10 +107,12 @@ function get(am, k) {
   return promise;
 }
 
-exports.LoaderTimeout = LoaderTimeout;
-exports.make = make;
-exports.deleteKey = deleteKey;
-exports.timeoutAfter = timeoutAfter;
-exports.loadNext = loadNext;
-exports.get = get;
+export {
+  LoaderTimeout ,
+  make ,
+  deleteKey ,
+  timeoutAfter ,
+  loadNext ,
+  get ,
+}
 /* Utils Not a pure module */