envio 3.5.0 → 3.5.1-svm-alpha.2

package/src/Config.res

@@ -59,11 +59,26 @@ type sourceSync = {
   pollingInterval: int,
 }
 
+// How a backend spells column names, mirroring `column_name_format` in
+// config.yaml. Only the internal columns the runtime appends need it — user
+// field names arrive pre-resolved from the CLI.
+type columnNameFormat = | @as("original") Original | @as("snake_case") SnakeCase
+
 type storage = {
   postgres: bool,
   clickhouse: bool,
+  postgresColumnNameFormat: columnNameFormat,
+  clickhouseColumnNameFormat: columnNameFormat,
 }
 
+let chainIdFieldName = "chainId"
+
+let chainIdColumnName = format =>
+  switch format {
+  | Original => chainIdFieldName
+  | SnakeCase => "chain_id"
+  }
+
 type contractHandler = {
   name: string,
   handler: option<string>,
@@ -76,6 +91,10 @@ type t = {
   contractHandlers: array<contractHandler>,
   shouldRollbackOnReorg: bool,
   shouldSaveFullHistory: bool,
+  // False when `disable_default_cross_chain: true` in config.yaml. Entities
+  // carry their own resolved `crossChain`; this only decides the default for
+  // effects that don't state one.
+  defaultCrossChain: bool,
   storage: storage,
   // Widest scalar the internal chain-id columns need, resolved by the CLI from
   // the maximum active chain id. Older configs predate the field, and every id
@@ -114,7 +133,8 @@ module EnvioAddresses = {
     id: string,
     @as("chain_id") chainId: ChainId.t,
     @as("registration_block") registrationBlock: int,
-    // -1 when the address was registered from a block handler (no log index)
+    // Vestigial: always written as -1 and never read back. The column stays so
+    // an existing schema doesn't need a migration.
     @as("registration_log_index") registrationLogIndex: int,
     @as("contract_name") contractName: string,
   }
@@ -160,6 +180,9 @@ module EnvioAddresses = {
     // always required to have Postgres enabled (Storage::resolve forbids
     // a Postgres-disabled global), so this is safe regardless of mode.
     storage: {postgres: true, clickhouse: false},
+    // The table already keys rows by chain through the composite `id`, so the
+    // per-chain mode must not append a second chain-id column to it.
+    crossChain: true,
   }->Internal.fromGenericEntityConfig
 }
 
@@ -352,6 +375,7 @@ let entityStorageSchema = S.schema(s =>
 let entityJsonSchema = S.schema(s =>
   {
     "name": s.matches(S.string),
+    "crossChain": s.matches(S.option(S.bool)),
     "storage": s.matches(S.option(entityStorageSchema)),
     "properties": s.matches(S.array(propertySchema)),
     "derivedFields": s.matches(S.option(S.array(derivedFieldSchema))),
@@ -423,13 +447,30 @@ let parseEnumsFromJson = (enumsJson: dict<array<string>>): array<Table.enumConfi
   )
 }
 
+// The chain-id column appended to a per-chain entity's table. It completes the
+// primary key so the same id can exist independently on every chain, and it's
+// spelled per backend because the two can be configured with different
+// `column_name_format`s.
+let makeChainIdField = (~globalStorage: storage) =>
+  Table.mkField(
+    chainIdFieldName,
+    ChainId,
+    ~fieldSchema=ChainId.schema,
+    ~isPrimaryKey=true,
+    ~isChainId=true,
+    ~postgresDbName=globalStorage.postgresColumnNameFormat->chainIdColumnName,
+    ~clickhouseDbName=globalStorage.clickhouseColumnNameFormat->chainIdColumnName,
+  )
+
 let parseEntitiesFromJson = (
   entitiesJson: array<'entityJson>,
   ~enumConfigsByName: dict<Table.enumConfig<Table.enum>>,
   ~globalStorage: storage,
+  ~defaultCrossChain: bool,
 ): array<Internal.entityConfig> => {
   entitiesJson->Array.mapWithIndex((entityJson, index) => {
     let entityName = entityJson["name"]
+    let crossChain = entityJson["crossChain"]->Option.getOr(defaultCrossChain)
 
     let fields: array<Table.fieldOrDerived> = entityJson["properties"]->Array.map(prop => {
       let (fieldType, fieldSchema, isNullable, isArray, isIndex) = getFieldTypeAndSchema(
@@ -477,7 +518,10 @@ let parseEntitiesFromJson = (
 
     let table = Table.mkTable(
       entityName,
-      ~fields=Array.concat(fields, derivedFields),
+      ~fields=Array.concatMany(
+        fields,
+        [crossChain ? [] : [makeChainIdField(~globalStorage)], derivedFields],
+      ),
       ~compositeIndexes,
       ~description=?entityJson["description"],
     )
@@ -535,14 +579,19 @@ let parseEntitiesFromJson = (
       schema: schema->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.entity>),
       table,
       storage,
+      crossChain,
     }->Internal.fromGenericEntityConfig
   })
 }
 
+let columnNameFormatSchema = S.enum([Original, SnakeCase])
+
 let publicConfigStorageSchema = S.schema(s =>
   {
     "postgres": s.matches(S.bool),
     "clickhouse": s.matches(S.option(S.bool)),
+    "postgresColumnNameFormat": s.matches(S.option(columnNameFormatSchema)),
+    "clickhouseColumnNameFormat": s.matches(S.option(columnNameFormatSchema)),
   }
 )
 
@@ -557,6 +606,7 @@ let publicConfigSchema = S.schema(s =>
     "saveFullHistory": s.matches(S.option(S.bool)),
     "rawEvents": s.matches(S.option(S.bool)),
     "chainIdMode": s.matches(S.option(ChainId.modeSchema)),
+    "defaultCrossChain": s.matches(S.option(S.bool)),
     "storage": s.matches(publicConfigStorageSchema),
     "evm": s.matches(S.option(publicConfigEvmSchema)),
     "fuel": s.matches(S.option(publicConfigEcosystemSchema)),
@@ -994,12 +1044,20 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   let globalStorage: storage = {
     postgres: publicConfig["storage"]["postgres"],
     clickhouse: publicConfig["storage"]["clickhouse"]->Option.getOr(false),
+    postgresColumnNameFormat: publicConfig["storage"]["postgresColumnNameFormat"]->Option.getOr(
+      Original,
+    ),
+    clickhouseColumnNameFormat: publicConfig["storage"]["clickhouseColumnNameFormat"]->Option.getOr(
+      Original,
+    ),
   }
 
+  let defaultCrossChain = publicConfig["defaultCrossChain"]->Option.getOr(true)
+
   let userEntities =
     publicConfig["entities"]
     ->Option.getOr([])
-    ->parseEntitiesFromJson(~enumConfigsByName, ~globalStorage)
+    ->parseEntitiesFromJson(~enumConfigsByName, ~globalStorage, ~defaultCrossChain)
 
   let allEntities = userEntities->Array.concat([EnvioAddresses.entityConfig])
 
@@ -1035,6 +1093,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     contractHandlers,
     shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getOr(true),
     shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getOr(false),
+    defaultCrossChain,
     storage: globalStorage,
     chainIdMode: publicConfig["chainIdMode"]->Option.getOr(Int32),
     chainMap,

package/src/Config.res.mjs

@@ -22,6 +22,16 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
+let chainIdFieldName = "chainId";
+
+function chainIdColumnName(format) {
+  if (format === "original") {
+    return chainIdFieldName;
+  } else {
+    return "chain_id";
+  }
+}
+
 let name = "envio_addresses";
 
 function makeId(chainId, address) {
@@ -42,11 +52,11 @@ let schema = S$RescriptSchema.schema(s => ({
 }));
 
 let table = Table.mkTable(name, undefined, [
-  Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_log_index", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("registration_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("registration_log_index", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
 ], undefined);
 
 let entityConfig_storage = {
@@ -59,7 +69,8 @@ let entityConfig = {
   index: -1,
   schema: schema,
   table: table,
-  storage: entityConfig_storage
+  storage: entityConfig_storage,
+  crossChain: true
 };
 
 let EnvioAddresses = {
@@ -217,6 +228,7 @@ let entityStorageSchema = S$RescriptSchema.schema(s => ({
 
 let entityJsonSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
+  crossChain: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   storage: s.m(S$RescriptSchema.option(entityStorageSchema)),
   properties: s.m(S$RescriptSchema.array(propertySchema)),
   derivedFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(derivedFieldSchema))),
@@ -324,19 +336,24 @@ function parseEnumsFromJson(enumsJson) {
   return Object.entries(enumsJson).map(param => Table.makeEnumConfig(param[0], param[1]));
 }
 
-function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage) {
+function makeChainIdField(globalStorage) {
+  return Table.mkField(chainIdFieldName, "ChainId", ChainId.schema, undefined, undefined, undefined, true, undefined, true, undefined, undefined, chainIdColumnName(globalStorage.postgresColumnNameFormat), chainIdColumnName(globalStorage.clickhouseColumnNameFormat));
+}
+
+function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage, defaultCrossChain) {
   return entitiesJson.map((entityJson, index) => {
     let entityName = entityJson.name;
+    let crossChain = Stdlib_Option.getOr(entityJson.crossChain, defaultCrossChain);
     let fields = entityJson.properties.map(prop => {
       let match = getFieldTypeAndSchema(prop, enumConfigsByName);
-      return Table.mkField(prop.name, match[0], match[1], undefined, match[3], match[2], prop.name === "id", match[4], prop.linkedEntity, prop.description, prop.postgresDbName, prop.clickhouseDbName);
+      return Table.mkField(prop.name, match[0], match[1], undefined, match[3], match[2], prop.name === "id", match[4], undefined, prop.linkedEntity, prop.description, prop.postgresDbName, prop.clickhouseDbName);
     });
     let derivedFields = Stdlib_Option.getOr(entityJson.derivedFields, []).map(df => Table.mkDerivedFromField(df.fieldName, df.derivedFromEntity, df.derivedFromField, df.description));
     let compositeIndexes = Stdlib_Option.getOr(entityJson.compositeIndices, []).map(ci => ci.map(f => ({
       fieldName: f.fieldName,
       direction: f.direction === "Asc" ? "Asc" : "Desc"
     })));
-    let table = Table.mkTable(entityName, compositeIndexes, fields.concat(derivedFields), entityJson.description);
+    let table = Table.mkTable(entityName, compositeIndexes, fields.concat(crossChain ? [] : [makeChainIdField(globalStorage)], derivedFields), entityJson.description);
     let getApiFieldName = prop => {
       let match = prop.linkedEntity;
       if (match !== undefined) {
@@ -382,14 +399,22 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage) {
       index: index,
       schema: schema,
       table: table,
-      storage: storage
+      storage: storage,
+      crossChain: crossChain
     };
   });
 }
 
+let columnNameFormatSchema = S$RescriptSchema.$$enum([
+  "original",
+  "snake_case"
+]);
+
 let publicConfigStorageSchema = S$RescriptSchema.schema(s => ({
   postgres: s.m(S$RescriptSchema.bool),
-  clickhouse: s.m(S$RescriptSchema.option(S$RescriptSchema.bool))
+  clickhouse: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+  postgresColumnNameFormat: s.m(S$RescriptSchema.option(columnNameFormatSchema)),
+  clickhouseColumnNameFormat: s.m(S$RescriptSchema.option(columnNameFormatSchema))
 }));
 
 let publicConfigSchema = S$RescriptSchema.schema(s => ({
@@ -402,6 +427,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   saveFullHistory: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   rawEvents: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   chainIdMode: s.m(S$RescriptSchema.option(ChainId.modeSchema)),
+  defaultCrossChain: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   storage: s.m(publicConfigStorageSchema),
   evm: s.m(S$RescriptSchema.option(publicConfigEvmSchema)),
   fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
@@ -689,11 +715,16 @@ function fromPublic(publicConfigJson) {
   ]));
   let globalStorage_postgres = publicConfig.storage.postgres;
   let globalStorage_clickhouse = Stdlib_Option.getOr(publicConfig.storage.clickhouse, false);
+  let globalStorage_postgresColumnNameFormat = Stdlib_Option.getOr(publicConfig.storage.postgresColumnNameFormat, "original");
+  let globalStorage_clickhouseColumnNameFormat = Stdlib_Option.getOr(publicConfig.storage.clickhouseColumnNameFormat, "original");
   let globalStorage = {
     postgres: globalStorage_postgres,
-    clickhouse: globalStorage_clickhouse
+    clickhouse: globalStorage_clickhouse,
+    postgresColumnNameFormat: globalStorage_postgresColumnNameFormat,
+    clickhouseColumnNameFormat: globalStorage_clickhouseColumnNameFormat
   };
-  let userEntities = parseEntitiesFromJson(Stdlib_Option.getOr(publicConfig.entities, []), enumConfigsByName, globalStorage);
+  let defaultCrossChain = Stdlib_Option.getOr(publicConfig.defaultCrossChain, true);
+  let userEntities = parseEntitiesFromJson(Stdlib_Option.getOr(publicConfig.entities, []), enumConfigsByName, globalStorage, defaultCrossChain);
   let allEntities = userEntities.concat([entityConfig]);
   let userEntitiesByName = Object.fromEntries(userEntities.map(entityConfig => [
     Utils.$$String.capitalize(entityConfig.name),
@@ -710,6 +741,7 @@ function fromPublic(publicConfigJson) {
     contractHandlers: contractHandlers,
     shouldRollbackOnReorg: Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true),
     shouldSaveFullHistory: Stdlib_Option.getOr(publicConfig.saveFullHistory, false),
+    defaultCrossChain: defaultCrossChain,
     storage: globalStorage,
     chainIdMode: Stdlib_Option.getOr(publicConfig.chainIdMode, "int32"),
     chainMap: chainMap,
@@ -1049,6 +1081,8 @@ function getPgUserEntities(config) {
 }
 
 export {
+  chainIdFieldName,
+  chainIdColumnName,
   EnvioAddresses,
   rpcSourceForSchema,
   rpcConfigSchema,
@@ -1069,7 +1103,9 @@ export {
   entityJsonSchema,
   getFieldTypeAndSchema,
   parseEnumsFromJson,
+  makeChainIdField,
   parseEntitiesFromJson,
+  columnNameFormatSchema,
   publicConfigStorageSchema,
   publicConfigSchema,
   fromPublic,

package/src/EffectState.res

@@ -131,7 +131,7 @@ let commitCacheCount = (inMemTable: effectCacheInMemTable, ~count) => {
 
 let statsToMetrics = (stats: effectStats): Metrics.effectMetrics => {
   Metrics.effect: stats.effectName,
-  scope: stats.scope->Internal.EffectCache.scopeToString,
+  scope: stats.scope->Internal.chainScopeToString,
   callSeconds: stats.callSeconds,
   callSecondsTotal: stats.callSecondsTotal,
   callCount: stats.callCount,
@@ -152,7 +152,7 @@ let toMetrics = (self: t): array<Metrics.effectMetrics> => {
     metrics
     ->Array.push({
       Metrics.effect: effectName,
-      scope: scope->Internal.EffectCache.scopeToString,
+      scope: scope->Internal.chainScopeToString,
       callSeconds: 0.,
       callSecondsTotal: 0.,
       callCount: 0.,

package/src/EffectState.res.mjs

@@ -68,7 +68,7 @@ function toMetrics(self) {
     let stats = t.stats;
     return {
       effect: stats.effectName,
-      scope: Internal.EffectCache.scopeToString(stats.scope),
+      scope: Internal.chainScopeToString(stats.scope),
       callSeconds: stats.callSeconds,
       callSecondsTotal: stats.callSecondsTotal,
       callCount: stats.callCount,
@@ -82,7 +82,7 @@ function toMetrics(self) {
   Utils.Dict.forEach(self.unregisteredCacheCounts, param => {
     metrics.push({
       effect: param.effectName,
-      scope: Internal.EffectCache.scopeToString(param.scope),
+      scope: Internal.chainScopeToString(param.scope),
       callSeconds: 0,
       callSecondsTotal: 0,
       callCount: 0,

package/src/EntityTables.res

@@ -0,0 +1,32 @@
+// One in-memory table per entity, for a single chain scope. The indexer holds
+// the cross-chain partition; each ChainState holds the per-chain one.
+
+type t = dict<InMemoryTable.Entity.t>
+
+exception UndefinedEntity({entityName: string})
+
+let make = (entities: array<Internal.entityConfig>): t => {
+  let init = Dict.make()
+  entities->Array.forEach(entityConfig => {
+    init->Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
+  })
+  init
+}
+
+let get = (self: t, ~entityName: string) => {
+  switch self->Utils.Dict.dangerouslyGetNonOption(entityName) {
+  | Some(table) => table
+  | None =>
+    UndefinedEntity({entityName: entityName})->ErrorHandling.mkLogAndRaise(
+      ~msg="Unexpected, entity InMemoryTable is undefined",
+    )
+  }
+}
+
+// Entities whose rows are shared by every chain, so their tables live on the
+// indexer rather than on a ChainState.
+let crossChain = (entities: array<Internal.entityConfig>) =>
+  entities->Array.filter((entityConfig: Internal.entityConfig) => entityConfig.crossChain)
+
+let perChain = (entities: array<Internal.entityConfig>) =>
+  entities->Array.filter((entityConfig: Internal.entityConfig) => !entityConfig.crossChain)

package/src/EntityTables.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let UndefinedEntity = /* @__PURE__ */Primitive_exceptions.create("EntityTables.UndefinedEntity");
+
+function make(entities) {
+  let init = {};
+  entities.forEach(entityConfig => {
+    init[entityConfig.name] = InMemoryTable.Entity.make();
+  });
+  return init;
+}
+
+function get(self, entityName) {
+  let table = self[entityName];
+  if (table !== undefined) {
+    return table;
+  } else {
+    return ErrorHandling.mkLogAndRaise(undefined, "Unexpected, entity InMemoryTable is undefined", {
+      RE_EXN_ID: UndefinedEntity,
+      entityName: entityName
+    });
+  }
+}
+
+function crossChain(entities) {
+  return entities.filter(entityConfig => entityConfig.crossChain);
+}
+
+function perChain(entities) {
+  return entities.filter(entityConfig => !entityConfig.crossChain);
+}
+
+export {
+  UndefinedEntity,
+  make,
+  get,
+  crossChain,
+  perChain,
+}
+/* ErrorHandling Not a pure module */

package/src/Envio.res

@@ -186,7 +186,8 @@ and effectOptions<'input, 'output> = {
   rateLimit: rateLimit,
   /** Whether the effect should be cached. */
   cache?: bool,
-  /** Whether the effect's cache is shared across all chains. Defaults to `true`.
+  /** Whether the effect's cache is shared across all chains. Defaults to `true`,
+   or to `false` when config.yaml sets `disable_default_cross_chain: true`.
    Set to `false` to isolate the cache (and rate limiting) per chain and enable
    `context.chain.id` inside the handler. */
   crossChain?: bool,
@@ -196,8 +197,8 @@ and effectContext = {
   log: logger,
   effect: 'input 'output. (effect<'input, 'output>, 'input) => promise<'output>,
   mutable cache: bool,
-  /** The chain the effect was called on. Only available on effects created with
-   `crossChain: false`; accessing it on a cross-chain effect throws. */
+  /** The chain the effect was called on. Only available on chain-scoped
+   effects; accessing it on a cross-chain effect throws. */
   chain: effectChain,
 }
 and effectArgs<'input> = {
@@ -259,10 +260,9 @@ let createEffect = (
     | Some(true) => true
     | _ => false
     },
-    crossChain: switch options.crossChain {
-    | Some(false) => false
-    | _ => true
-    },
+    // Left unresolved: the config's `defaultCrossChain` fills it in when the
+    // effect didn't state one, and the config isn't available here.
+    crossChain: options.crossChain,
     rateLimit: switch options.rateLimit {
     | Disable => None
     | Enable({calls, per}) =>

package/src/Envio.res.mjs

@@ -30,12 +30,11 @@ function createEffect(options, handler) {
     output: s.m(outputSchema)
   }));
   let match = options.cache;
-  let match$1 = options.crossChain;
-  let match$2 = options.rateLimit;
+  let match$1 = options.rateLimit;
   let tmp;
-  tmp = match$2 === false ? undefined : ({
-      callsPerDuration: match$2.calls,
-      durationMs: durationToMs(match$2.per)
+  tmp = match$1 === false ? undefined : ({
+      callsPerDuration: match$1.calls,
+      durationMs: durationToMs(match$1.per)
     });
   return {
     name: options.name,
@@ -45,7 +44,7 @@ function createEffect(options, handler) {
       outputSchema: outputSchema
     },
     defaultShouldCache: match !== undefined ? match : false,
-    crossChain: match$1 !== undefined ? match$1 : true,
+    crossChain: options.crossChain,
     output: outputSchema,
     input: S$RescriptSchema.schema(param => options.input),
     rateLimit: tmp