envio 3.13.0 → 3.14.0-subgraph

package/src/SyncWrites.res.mjs

@@ -0,0 +1,85 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as EntityId from "./EntityId.res.mjs";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function make() {
+  return {};
+}
+
+function record(writes, entityConfig, scope, change) {
+  let table = writes[entityConfig.name];
+  let table$1;
+  if (table !== undefined) {
+    table$1 = table;
+  } else {
+    let table_changes = {};
+    let table$2 = {
+      entityConfig: entityConfig,
+      scope: scope,
+      changes: table_changes
+    };
+    writes[entityConfig.name] = table$2;
+    table$1 = table$2;
+  }
+  table$1.changes[EntityId.toKey(change.entityId)] = change;
+}
+
+function changesOf(writes, entityConfig) {
+  let match = writes[entityConfig.name];
+  if (match !== undefined) {
+    return match.changes;
+  }
+}
+
+function getById(writes, entityConfig, entityId) {
+  let changes = changesOf(writes, entityConfig);
+  if (changes !== undefined) {
+    return Stdlib_Option.map(changes[entityId], InMemoryTable.Entity.mapChangeToEntity);
+  }
+}
+
+function overlayFilter(writes, entities, entityConfig, filter) {
+  let changes = changesOf(writes, entityConfig);
+  if (changes === undefined) {
+    return entities;
+  }
+  let matches = EntityFilter.makeMatcher(filter, entityConfig.table);
+  let untouched = entities.filter(entity => !(InMemoryTable.Entity.getEntityIdUnsafe(entity) in changes));
+  let written = Stdlib_Array.filterMap(Object.values(changes), change => {
+    let entity = InMemoryTable.Entity.mapChangeToEntity(change);
+    if (entity !== undefined && matches(entity)) {
+      return entity;
+    }
+  });
+  return untouched.concat(written);
+}
+
+function write(indexerState, entityConfig, scope, change) {
+  InMemoryTable.Entity.set(InMemoryStore.getInMemTable(indexerState, entityConfig, scope), IndexerState.committedCheckpointIdFor(indexerState, scope), change);
+}
+
+function commit(writes, indexerState) {
+  Utils.Dict.forEach(writes, param => {
+    let scope = param.scope;
+    let entityConfig = param.entityConfig;
+    Utils.Dict.forEach(param.changes, change => write(indexerState, entityConfig, scope, change));
+  });
+}
+
+export {
+  make,
+  record,
+  changesOf,
+  getById,
+  overlayFilter,
+  write,
+  commit,
+}
+/* Utils Not a pure module */

package/src/TestIndexer.res

@@ -275,7 +275,6 @@ let makeInitialState = (
   {
     cleanRun: true,
     contractMapping,
-    envioInfo: Some(JSON.Encode.object(Dict.make())),
     cache: Dict.make(),
     chains,
     checkpointFrontier: Frontier.empty(),
@@ -567,7 +566,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   isInitialized: async () => true,
   // The runner injects the config-derived initial state by setting
   // `persistence.storageStatus = Ready(...)` directly, bypassing `Persistence.init`,
-  // so neither of these is reached.
+  // so none of these is reached.
   initialize: async (
     ~chainConfigs as _=?,
     ~entities as _=?,
@@ -578,7 +577,15 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~chainIds as _, ~throwIfIncompatible as _) =>
+  readStoredConfig: async () =>
+    JsError.throwWithMessage(
+      "TestIndexer: readStoredConfig should not be called; the initial state is derived from config.",
+    ),
+  addChain: async (~chainConfig as _, ~entities as _, ~contractMapping as _) =>
+    JsError.throwWithMessage(
+      "TestIndexer: addChain should not be called; the initial state is derived from config.",
+    ),
+  resumeInitialState: async (~entities as _, ~chainIds as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -666,7 +673,10 @@ let getRegistrations = (~config) =>
   switch registrationsRef.contents {
   | Some(promise) => promise
   | None =>
-    let promise = HandlerLoader.registerAllHandlers(~config)
+    let promise =
+      HandlerLoader.getAutoLoadFiles(~config)->Promise.then(autoLoadFiles =>
+        HandlerLoader.registerAllHandlers(~config, ~autoLoadFiles)
+      )
     registrationsRef := Some(promise)
     promise
   }

package/src/TestIndexer.res.mjs

@@ -195,7 +195,6 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
   return {
     cleanRun: true,
     contractMapping: contractMapping,
-    envioInfo: {},
     cache: {},
     chains: chains,
     checkpointFrontier: Frontier.empty(),
@@ -388,6 +387,8 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    readStoredConfig: async () => Stdlib_JsError.throwWithMessage("TestIndexer: readStoredConfig should not be called; the initial state is derived from config."),
+    addChain: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
     resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1, param$2) => {},
@@ -427,7 +428,7 @@ function getRegistrations(config) {
   if (promise !== undefined) {
     return promise;
   }
-  let promise$1 = HandlerLoader.registerAllHandlers(config);
+  let promise$1 = HandlerLoader.getAutoLoadFiles(config).then(autoLoadFiles => HandlerLoader.registerAllHandlers(config, autoLoadFiles));
   registrationsRef.contents = promise$1;
   return promise$1;
 }

package/src/TsModuleHooks.mjs

@@ -0,0 +1,121 @@
+import module from "node:module";
+import { fileURLToPath } from "node:url";
+import { unsupportedNodeMessage } from "./NodeVersion.mjs";
+
+const TS_URL = /\.[cm]?tsx?$/;
+const JSON_URL = /\.json($|\?)/;
+const NOT_FOUND_CODES = new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+]);
+
+let registered = false;
+
+// Node's own resolver still resolves every candidate the addon offers, so
+// package exports and conditions behave as they do without the hooks.
+export const register = (addon) => {
+  if (registered) return;
+  registered = true;
+
+  // The CLI checks this first thing; a test indexer gets here without it.
+  const unsupported = unsupportedNodeMessage();
+  if (unsupported !== undefined) throw new Error(unsupported);
+
+  // Node ignores the source maps `loadTs` inlines unless this is on.
+  module.setSourceMapsSupport(true);
+
+  // What legacy decorators lower to; tslib's `__decorate`, `__param` and
+  // `__metadata`.
+  const helpers = (globalThis.babelHelpers ??= {});
+  // A function rather than an arrow: the argument count tells a class
+  // decorator from a member's.
+  helpers.decorate ??= function (decorators, target, key, descriptor) {
+    const argumentCount = arguments.length;
+    let result =
+      argumentCount < 3
+        ? target
+        : descriptor === null
+          ? (descriptor = Object.getOwnPropertyDescriptor(target, key))
+          : descriptor;
+    for (let index = decorators.length - 1; index >= 0; index--) {
+      const decorator = decorators[index];
+      if (decorator) {
+        result =
+          (argumentCount < 3
+            ? decorator(result)
+            : argumentCount > 3
+              ? decorator(target, key, result)
+              : decorator(target, key)) || result;
+      }
+    }
+    if (argumentCount > 3 && result) Object.defineProperty(target, key, result);
+    return result;
+  };
+  helpers.decorateParam ??= (index, decorator) => (target, key) => decorator(target, key, index);
+  helpers.decorateMetadata ??= (key, value) =>
+    typeof Reflect === "object" && typeof Reflect.metadata === "function"
+      ? Reflect.metadata(key, value)
+      : undefined;
+
+  const firstResolved = (candidates, context, nextResolve) => {
+    for (const candidate of candidates) {
+      try {
+        return nextResolve(candidate, context);
+      } catch (error) {
+        if (!NOT_FOUND_CODES.has(error?.code)) throw error;
+      }
+    }
+    return undefined;
+  };
+
+  module.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      // Handlers are ES modules, so `require()` only comes from dependencies,
+      // including the one Node makes to read a CommonJS module's named
+      // exports. It resolves as it would without the hooks.
+      if (specifier.startsWith("node:") || context.conditions?.includes("require")) {
+        return nextResolve(specifier, context);
+      }
+      const [path, query] = specifier.split("?");
+      let resolved = firstResolved(
+        addon.tsResolveCandidates(path, context.parentURL ?? null),
+        context,
+        nextResolve
+      );
+      if (resolved === undefined) {
+        try {
+          resolved = nextResolve(path, context);
+        } catch (error) {
+          resolved =
+            NOT_FOUND_CODES.has(error?.code) &&
+            firstResolved(
+              addon.tsNotFoundCandidates(error.code, error.url ?? null, error.message),
+              context,
+              nextResolve
+            );
+          if (!resolved) throw error;
+        }
+      }
+      const url = query ? `${resolved.url}?${query}` : resolved.url;
+      // TypeScript's `resolveJsonModule` imports JSON without the
+      // `type: "json"` attribute Node requires.
+      if (JSON_URL.test(url) && context.importAttributes?.type === undefined) {
+        return {
+          ...resolved,
+          url,
+          importAttributes: { ...context.importAttributes, type: "json" },
+          shortCircuit: true,
+        };
+      }
+      return { ...resolved, url, shortCircuit: true };
+    },
+
+    load(url, context, nextLoad) {
+      if (!url.startsWith("file:") || !TS_URL.test(new URL(url).pathname)) {
+        return nextLoad(url, context);
+      }
+      return { format: "module", source: addon.loadTs(fileURLToPath(url)), shortCircuit: true };
+    },
+  });
+};