envio 2.21.5 → 2.22.1

package/src/Logging.res.js

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Pino = require("./bindings/Pino.res.js");
+var Pino$1 = require("pino");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Internal = require("./Internal.res.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var EcsPinoFormat = require("@elastic/ecs-pino-format");
+
+var logLevels = Js_dict.fromArray([
+      [
+        "udebug",
+        32
+      ],
+      [
+        "uinfo",
+        34
+      ],
+      [
+        "uwarn",
+        36
+      ],
+      [
+        "uerror",
+        38
+      ],
+      [
+        "trace",
+        10
+      ],
+      [
+        "debug",
+        20
+      ],
+      [
+        "info",
+        30
+      ],
+      [
+        "warn",
+        40
+      ],
+      [
+        "error",
+        50
+      ],
+      [
+        "fatal",
+        60
+      ]
+    ]);
+
+var logger = {
+  contents: undefined
+};
+
+function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel) {
+  var pinoFile_target = "pino/file";
+  var pinoFile_options = Caml_option.some(Pino.Transport.makeTransportOptions({
+            destination: logFilePath,
+            append: true,
+            mkdir: true
+          }));
+  var pinoFile_level = defaultFileLogLevel;
+  var pinoFile = {
+    target: pinoFile_target,
+    options: pinoFile_options,
+    level: pinoFile_level
+  };
+  var makeMultiStreamLogger = function (none, none$1) {
+    return Pino.MultiStreamLogger.make(userLogLevel, logLevels, none, none$1, defaultFileLogLevel);
+  };
+  switch (logStrategy) {
+    case "ecs-file" :
+        var newrecord = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
+    case "ecs-console" :
+        var newrecord$1 = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
+    case "ecs-console-multistream" :
+        return makeMultiStreamLogger(undefined, EcsPinoFormat());
+    case "file-only" :
+        return Pino$1({
+                    level: defaultFileLogLevel,
+                    customLevels: logLevels
+                  }, Pino$1.transport(pinoFile));
+    case "console-raw" :
+    case "console-pretty" :
+        return makeMultiStreamLogger(undefined, undefined);
+    case "both-prettyconsole" :
+        return makeMultiStreamLogger(logFilePath, undefined);
+    
+  }
+}
+
+function setLogger(l) {
+  logger.contents = l;
+}
+
+function getLogger() {
+  var logger$1 = logger.contents;
+  if (logger$1 !== undefined) {
+    return logger$1;
+  } else {
+    return Js_exn.raiseError("Unreachable code. Logger not initialized");
+  }
+}
+
+function setLogLevel(level) {
+  getLogger().level = level;
+}
+
+function trace(message) {
+  getLogger().trace(Pino.createPinoMessage(message));
+}
+
+function debug(message) {
+  getLogger().debug(Pino.createPinoMessage(message));
+}
+
+function info(message) {
+  getLogger().info(Pino.createPinoMessage(message));
+}
+
+function warn(message) {
+  getLogger().warn(Pino.createPinoMessage(message));
+}
+
+function error(message) {
+  getLogger().error(Pino.createPinoMessage(message));
+}
+
+function errorWithExn(error, message) {
+  getLogger().error(Pino.createPinoMessageWithError(message, error));
+}
+
+function fatal(message) {
+  getLogger().fatal(Pino.createPinoMessage(message));
+}
+
+function childTrace(logger, params) {
+  logger.trace(Pino.createPinoMessage(params));
+}
+
+function childDebug(logger, params) {
+  logger.debug(Pino.createPinoMessage(params));
+}
+
+function childInfo(logger, params) {
+  logger.info(Pino.createPinoMessage(params));
+}
+
+function childWarn(logger, params) {
+  logger.warn(Pino.createPinoMessage(params));
+}
+
+function childError(logger, params) {
+  logger.error(Pino.createPinoMessage(params));
+}
+
+function childErrorWithExn(logger, error, params) {
+  logger.error(Pino.createPinoMessageWithError(params, error));
+}
+
+function childFatal(logger, params) {
+  logger.fatal(Pino.createPinoMessage(params));
+}
+
+function createChild(params) {
+  return getLogger().child(Pino.createChildParams(params));
+}
+
+function createChildFrom(logger, params) {
+  return logger.child(Pino.createChildParams(params));
+}
+
+function getEventLogger(eventItem) {
+  var l = eventItem.loggerCache;
+  if (l !== undefined) {
+    return l;
+  }
+  var l$1 = getLogger().child(Pino.createChildParams({
+            contractName: eventItem.eventConfig.contractName,
+            eventName: eventItem.eventConfig.name,
+            chainId: eventItem.chain,
+            block: eventItem.blockNumber,
+            logIndex: eventItem.logIndex
+          }));
+  eventItem.loggerCache = l$1;
+  return l$1;
+}
+
+function logForItem(eventItem, level, message, params) {
+  return getEventLogger(eventItem)[level](params, message);
+}
+
+function getUserLogger(eventItem) {
+  return {
+          debug: (function (message, params) {
+              getEventLogger(eventItem)["udebug"](params, message);
+            }),
+          info: (function (message, params) {
+              getEventLogger(eventItem)["uinfo"](params, message);
+            }),
+          warn: (function (message, params) {
+              getEventLogger(eventItem)["uwarn"](params, message);
+            }),
+          error: (function (message, params) {
+              getEventLogger(eventItem)["uerror"](params, message);
+            }),
+          errorWithExn: (function (message, exn) {
+              var params = {
+                err: Internal.prettifyExn(exn)
+              };
+              getEventLogger(eventItem)["uerror"](params, message);
+            })
+        };
+}
+
+exports.logLevels = logLevels;
+exports.makeLogger = makeLogger;
+exports.setLogger = setLogger;
+exports.getLogger = getLogger;
+exports.setLogLevel = setLogLevel;
+exports.trace = trace;
+exports.debug = debug;
+exports.info = info;
+exports.warn = warn;
+exports.error = error;
+exports.errorWithExn = errorWithExn;
+exports.fatal = fatal;
+exports.childTrace = childTrace;
+exports.childDebug = childDebug;
+exports.childInfo = childInfo;
+exports.childWarn = childWarn;
+exports.childError = childError;
+exports.childErrorWithExn = childErrorWithExn;
+exports.childFatal = childFatal;
+exports.createChild = createChild;
+exports.createChildFrom = createChildFrom;
+exports.getEventLogger = getEventLogger;
+exports.logForItem = logForItem;
+exports.getUserLogger = getUserLogger;
+/* logLevels Not a pure module */

package/src/Persistence.res

@@ -0,0 +1,111 @@
+// A module for the persistence layer
+// This is currently in a WIP state
+// but in the future we should make all DB and in-memory state
+// interactions to this layer with DI and easy for testing.
+// Currently there are quite many code spread across
+// DbFunctions, Db, Migrations, InMemoryStore modules which use codegen code directly.
+
+type storage = {
+  // Should return true if we already have persisted data
+  // and we can skip initialization
+  isInitialized: unit => promise<bool>,
+  // Should initialize the storage so we can start interacting with it
+  // Eg create connection, schema, tables, etc.
+  initialize: (
+    ~entities: array<Internal.entityConfig>,
+    ~staticTables: array<Table.table>,
+    ~enums: array<Internal.enumConfig<Internal.enum>>,
+    // If true, the storage should clear existing data
+    ~cleanRun: bool,
+  ) => promise<unit>,
+}
+
+type storageStatus =
+  | Unknown
+  | Initializing(promise<unit>)
+  | Ready({cleanRun: bool})
+
+type t = {
+  userEntities: array<Internal.entityConfig>,
+  staticTables: array<Table.table>,
+  allEntities: array<Internal.entityConfig>,
+  allEnums: array<Internal.enumConfig<Internal.enum>>,
+  mutable storageStatus: storageStatus,
+  storage: storage,
+  onStorageInitialize: option<unit => promise<unit>>,
+}
+
+let entityHistoryActionEnumConfig: Internal.enumConfig<EntityHistory.RowAction.t> = {
+  name: EntityHistory.RowAction.name,
+  variants: EntityHistory.RowAction.variants,
+  schema: EntityHistory.RowAction.schema,
+  default: SET,
+}
+
+let make = (
+  ~userEntities,
+  ~dcRegistryEntityConfig,
+  // TODO: Should only pass userEnums and create internal config in runtime
+  ~allEnums,
+  ~staticTables,
+  ~storage,
+  ~onStorageInitialize=?,
+) => {
+  let allEntities = userEntities->Js.Array2.concat([dcRegistryEntityConfig])
+  let allEnums =
+    allEnums->Js.Array2.concat([entityHistoryActionEnumConfig->Internal.fromGenericEnumConfig])
+  {
+    userEntities,
+    staticTables,
+    allEntities,
+    allEnums,
+    storageStatus: Unknown,
+    storage,
+    onStorageInitialize,
+  }
+}
+
+let init = async (
+  persistence,
+  // There are not much sense in the option,
+  // but this is how the runUpMigration used to work
+  // and we want to keep the upsert behavior without breaking changes.
+  ~skipIsInitializedCheck=false,
+  ~reset=false,
+) => {
+  try {
+    let shouldRun = switch persistence.storageStatus {
+    | Unknown => true
+    | Initializing(promise) => {
+        await promise
+        reset
+      }
+    | Ready(_) => reset
+    }
+    if shouldRun {
+      let resolveRef = ref(%raw(`null`))
+      let promise = Promise.make((resolve, _) => {
+        resolveRef := resolve
+      })
+      persistence.storageStatus = Initializing(promise)
+      if !(reset || skipIsInitializedCheck) && (await persistence.storage.isInitialized()) {
+        persistence.storageStatus = Ready({cleanRun: false})
+      } else {
+        let _ = await persistence.storage.initialize(
+          ~entities=persistence.allEntities,
+          ~staticTables=persistence.staticTables,
+          ~enums=persistence.allEnums,
+          ~cleanRun=reset || !skipIsInitializedCheck,
+        )
+        persistence.storageStatus = Ready({cleanRun: true})
+        switch persistence.onStorageInitialize {
+        | Some(onStorageInitialize) => await onStorageInitialize()
+        | None => ()
+        }
+      }
+      resolveRef.contents()
+    }
+  } catch {
+  | exn => exn->ErrorHandling.mkLogAndRaise(~msg=`EE800: Failed to initialize the indexer storage.`)
+  }
+}

package/src/Persistence.res.js

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var EntityHistory = require("./db/EntityHistory.res.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var entityHistoryActionEnumConfig_name = EntityHistory.RowAction.name;
+
+var entityHistoryActionEnumConfig_variants = EntityHistory.RowAction.variants;
+
+var entityHistoryActionEnumConfig_schema = EntityHistory.RowAction.schema;
+
+var entityHistoryActionEnumConfig = {
+  name: entityHistoryActionEnumConfig_name,
+  variants: entityHistoryActionEnumConfig_variants,
+  schema: entityHistoryActionEnumConfig_schema,
+  default: "SET"
+};
+
+function make(userEntities, dcRegistryEntityConfig, allEnums, staticTables, storage, onStorageInitialize) {
+  var allEntities = userEntities.concat([dcRegistryEntityConfig]);
+  var allEnums$1 = allEnums.concat([entityHistoryActionEnumConfig]);
+  return {
+          userEntities: userEntities,
+          staticTables: staticTables,
+          allEntities: allEntities,
+          allEnums: allEnums$1,
+          storageStatus: "Unknown",
+          storage: storage,
+          onStorageInitialize: onStorageInitialize
+        };
+}
+
+async function init(persistence, skipIsInitializedCheckOpt, resetOpt) {
+  var skipIsInitializedCheck = skipIsInitializedCheckOpt !== undefined ? skipIsInitializedCheckOpt : false;
+  var reset = resetOpt !== undefined ? resetOpt : false;
+  try {
+    var promise = persistence.storageStatus;
+    var shouldRun;
+    if (typeof promise !== "object") {
+      shouldRun = true;
+    } else if (promise.TAG === "Initializing") {
+      await promise._0;
+      shouldRun = reset;
+    } else {
+      shouldRun = reset;
+    }
+    if (!shouldRun) {
+      return ;
+    }
+    var resolveRef = {
+      contents: null
+    };
+    var promise$1 = new Promise((function (resolve, param) {
+            resolveRef.contents = resolve;
+          }));
+    persistence.storageStatus = {
+      TAG: "Initializing",
+      _0: promise$1
+    };
+    if (!(reset || skipIsInitializedCheck) && await persistence.storage.isInitialized()) {
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: false
+      };
+    } else {
+      await persistence.storage.initialize(persistence.allEntities, persistence.staticTables, persistence.allEnums, reset || !skipIsInitializedCheck);
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: true
+      };
+      var onStorageInitialize = persistence.onStorageInitialize;
+      if (onStorageInitialize !== undefined) {
+        await onStorageInitialize();
+      }
+      
+    }
+    return resolveRef.contents();
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return ErrorHandling.mkLogAndRaise(undefined, "EE800: Failed to initialize the indexer storage.", exn);
+  }
+}
+
+exports.entityHistoryActionEnumConfig = entityHistoryActionEnumConfig;
+exports.make = make;
+exports.init = init;
+/* EntityHistory Not a pure module */

package/src/PgStorage.res

@@ -0,0 +1,165 @@
+let makeCreateIndexSqlUnsafe = (~tableName, ~indexFields, ~pgSchema) => {
+  let indexName = tableName ++ "_" ++ indexFields->Js.Array2.joinWith("_")
+  let index = indexFields->Belt.Array.map(idx => `"${idx}"`)->Js.Array2.joinWith(", ")
+  `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${pgSchema}"."${tableName}"(${index});`
+}
+
+let makeCreateTableIndicesSqlUnsafe = (table: Table.table, ~pgSchema) => {
+  open Belt
+  let tableName = table.tableName
+  let createIndex = indexField =>
+    makeCreateIndexSqlUnsafe(~tableName, ~indexFields=[indexField], ~pgSchema)
+  let createCompositeIndex = indexFields => {
+    makeCreateIndexSqlUnsafe(~tableName, ~indexFields, ~pgSchema)
+  }
+
+  let singleIndices = table->Table.getSingleIndices
+  let compositeIndices = table->Table.getCompositeIndices
+
+  singleIndices->Array.map(createIndex)->Js.Array2.joinWith("\n") ++
+    compositeIndices->Array.map(createCompositeIndex)->Js.Array2.joinWith("\n")
+}
+
+let makeCreateTableSqlUnsafe = (table: Table.table, ~pgSchema) => {
+  open Belt
+  let fieldsMapped =
+    table
+    ->Table.getFields
+    ->Array.map(field => {
+      let {fieldType, isNullable, isArray, defaultValue} = field
+      let fieldName = field->Table.getDbFieldName
+
+      {
+        `"${fieldName}" ${switch fieldType {
+          | Custom(name) if !(name->Js.String2.startsWith("NUMERIC(")) => `"${pgSchema}".${name}`
+          | _ => (fieldType :> string)
+          }}${isArray ? "[]" : ""}${switch defaultValue {
+          | Some(defaultValue) => ` DEFAULT ${defaultValue}`
+          | None => isNullable ? `` : ` NOT NULL`
+          }}`
+      }
+    })
+    ->Js.Array2.joinWith(", ")
+
+  let primaryKeyFieldNames = table->Table.getPrimaryKeyFieldNames
+  let primaryKey =
+    primaryKeyFieldNames
+    ->Array.map(field => `"${field}"`)
+    ->Js.Array2.joinWith(", ")
+
+  `CREATE TABLE IF NOT EXISTS "${pgSchema}"."${table.tableName}"(${fieldsMapped}${primaryKeyFieldNames->Array.length > 0
+      ? `, PRIMARY KEY(${primaryKey})`
+      : ""});`
+}
+
+let makeInitializeTransaction = (~pgSchema, ~staticTables, ~entities, ~enums, ~cleanRun) => {
+  let allTables = staticTables->Array.copy
+  let allEntityTables = []
+  entities->Js.Array2.forEach((entity: Internal.entityConfig) => {
+    allEntityTables->Js.Array2.push(entity.table)->ignore
+    allTables->Js.Array2.push(entity.table)->ignore
+    allTables->Js.Array2.push(entity.entityHistory.table)->ignore
+  })
+  let derivedSchema = Schema.make(allEntityTables)
+
+  let query = ref(
+    (
+      cleanRun
+        ? `DROP SCHEMA IF EXISTS "${pgSchema}" CASCADE;
+CREATE SCHEMA "${pgSchema}";`
+        : `CREATE SCHEMA IF NOT EXISTS "${pgSchema}";`
+    ) ++
+    `GRANT ALL ON SCHEMA "${pgSchema}" TO postgres;
+GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
+  )
+
+  // Optimized enum creation - direct when cleanRun, conditional otherwise
+  enums->Js.Array2.forEach((enumConfig: Internal.enumConfig<Internal.enum>) => {
+    // Create base enum creation query once
+    let enumCreateQuery = `CREATE TYPE "${pgSchema}".${enumConfig.name} AS ENUM(${enumConfig.variants
+      ->Js.Array2.map(v => `'${v->(Utils.magic: Internal.enum => string)}'`)
+      ->Js.Array2.joinWith(", ")});`
+
+    query :=
+      query.contents ++
+      "\n" ++ if cleanRun {
+        // Direct creation when cleanRunting (faster)
+        enumCreateQuery
+      } else {
+        // Wrap with conditional check only when not cleanRunting
+        `IF NOT EXISTS (
+  SELECT 1 FROM pg_type 
+  WHERE typname = '${enumConfig.name->Js.String2.toLowerCase}' 
+  AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '${pgSchema}')
+) THEN 
+    ${enumCreateQuery}
+END IF;`
+      }
+  })
+
+  // Batch all table creation first (optimal for PostgreSQL)
+  allTables->Js.Array2.forEach((table: Table.table) => {
+    query := query.contents ++ "\n" ++ makeCreateTableSqlUnsafe(table, ~pgSchema)
+  })
+
+  // Then batch all indices (better performance when tables exist)
+  allTables->Js.Array2.forEach((table: Table.table) => {
+    let indices = makeCreateTableIndicesSqlUnsafe(table, ~pgSchema)
+    if indices !== "" {
+      query := query.contents ++ "\n" ++ indices
+    }
+  })
+
+  let functionsQuery = ref("")
+
+  // Add derived indices
+  entities->Js.Array2.forEach((entity: Internal.entityConfig) => {
+    functionsQuery := functionsQuery.contents ++ "\n" ++ entity.entityHistory.createInsertFnQuery
+
+    entity.table
+    ->Table.getDerivedFromFields
+    ->Js.Array2.forEach(derivedFromField => {
+      let indexField =
+        derivedSchema->Schema.getDerivedFromFieldName(derivedFromField)->Utils.unwrapResultExn
+      query :=
+        query.contents ++
+        "\n" ++
+        makeCreateIndexSqlUnsafe(
+          ~tableName=derivedFromField.derivedFromEntity,
+          ~indexFields=[indexField],
+          ~pgSchema,
+        )
+    })
+  })
+
+  [
+    // Return optimized queries - main DDL in DO block, functions separate
+    // Note: DO $$ BEGIN wrapper is only needed for PL/pgSQL conditionals (IF NOT EXISTS)
+    // Reset case uses direct DDL (faster), non-cleanRun case uses conditionals (safer)
+    cleanRun ? query.contents : `DO $$ BEGIN ${query.contents} END $$;`,
+    // Functions query (separate as they can't be in DO block)
+  ]->Js.Array2.concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : [])
+}
+
+let make = (~sql: Postgres.sql, ~pgSchema): Persistence.storage => {
+  let isInitialized = async () => {
+    let schemas =
+      await sql->Postgres.unsafe(
+        `SELECT schema_name FROM information_schema.schemata WHERE schema_name = '${pgSchema}';`,
+      )
+    schemas->Utils.Array.notEmpty
+  }
+
+  let initialize = async (~entities, ~staticTables, ~enums, ~cleanRun) => {
+    let queries = makeInitializeTransaction(~pgSchema, ~staticTables, ~entities, ~enums, ~cleanRun)
+    // Execute all queries within a single transaction for integrity
+    let _ = await sql->Postgres.beginSql(sql => {
+      queries->Js.Array2.map(query => sql->Postgres.unsafe(query))
+    })
+  }
+
+  {
+    isInitialized,
+    initialize,
+  }
+}