envio 3.14.0-subgraph → 3.14.1

package/evm.schema.json

@@ -543,7 +543,7 @@
       "type": "object",
       "properties": {
         "url": {
-          "description": "The RPC endpoint URL.",
+          "description": "The RPC endpoint URL. An entry whose url is empty, for example `${RPC_URL:-}` with the variable unset, is ignored.",
           "type": "string"
         },
         "for": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.14.0-subgraph",
+  "version": "3.14.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -54,10 +54,10 @@
     "postgres": "3.4.8"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.14.0-subgraph",
-    "envio-linux-x64-musl": "3.14.0-subgraph",
-    "envio-linux-arm64": "3.14.0-subgraph",
-    "envio-darwin-x64": "3.14.0-subgraph",
-    "envio-darwin-arm64": "3.14.0-subgraph"
+    "envio-linux-x64": "3.14.1",
+    "envio-linux-x64-musl": "3.14.1",
+    "envio-linux-arm64": "3.14.1",
+    "envio-darwin-x64": "3.14.1",
+    "envio-darwin-arm64": "3.14.1"
   }
 }

package/src/Config.res

@@ -151,9 +151,6 @@ type t = {
   // reach, so its checkpoints have to be comparable across chains.
   checkpointSequence: CheckpointSequence.t,
   envioInfo: JSON.t,
-  // Set only in subgraph mode: the translated manifest, which is what makes
-  // the subgraph runtime take over handler registration.
-  subgraph: option<JSON.t>,
 }
 
 type rpcSourceFor = | @as("sync") Sync | @as("fallback") Fallback | @as("realtime") Realtime
@@ -615,7 +612,6 @@ let publicConfigSchema = S.schema(s =>
     "svm": s.matches(S.option(publicConfigEcosystemSchema)),
     "enums": s.matches(S.option(S.dict(S.array(S.string)))),
     "entities": s.matches(S.option(S.array(entityJsonSchema))),
-    "subgraph": s.matches(S.option(S.json(~validate=false))),
   }
 )
 
@@ -698,10 +694,6 @@ let toEnvioInfo = (publicConfigJson: JSON.t): JSON.t => {
   switch envioInfo {
   | Object(obj) => {
       commandFields->Array.forEach(field => obj->Utils.Dict.deleteInPlace(field))
-      // The subgraph blob is how the runtime finds mappings. None of it
-      // describes stored data — that's already in `evm` / `entities` — so a
-      // specVersion bump or a mapping-path edit must not force a reset.
-      obj->Utils.Dict.deleteInPlace("subgraph")
       ecosystemFields->Array.forEach(ecosystem =>
         switch obj->Dict.get(ecosystem) {
         | Some(Object(ecosystemDict)) => ecosystemDict->Utils.Dict.deleteInPlace("chains")
@@ -1191,7 +1183,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     allEnums,
     checkpointSequence: CheckpointSequence.fromEntities(userEntities),
     envioInfo: publicConfigJson->toEnvioInfo,
-    subgraph: publicConfig["subgraph"],
   }
 
   switch publicConfig["isolatedChains"] {

package/src/Config.res.mjs

@@ -450,8 +450,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   svm: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   enums: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(S$RescriptSchema.array(S$RescriptSchema.string)))),
-  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema))),
-  subgraph: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
+  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema)))
 }));
 
 function contractMappingOf(chainConfigs) {
@@ -521,7 +520,6 @@ function toEnvioInfo(publicConfigJson) {
   let envioInfo = JSON.parse(JSON.stringify(publicConfigJson));
   if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
     commandFields.forEach(field => Utils.Dict.deleteInPlace(envioInfo, field));
-    Utils.Dict.deleteInPlace(envioInfo, "subgraph");
     ecosystemFields.forEach(ecosystem => {
       let match = envioInfo[ecosystem];
       if (typeof match === "object" && match !== null && !Array.isArray(match)) {
@@ -841,7 +839,6 @@ function fromPublic(publicConfigJson) {
   let config_projectFlags = Stdlib_Option.getOr(publicConfig.projectFlags, "");
   let config_checkpointSequence = CheckpointSequence.fromEntities(userEntities);
   let config_envioInfo = toEnvioInfo(publicConfigJson);
-  let config_subgraph = publicConfig.subgraph;
   let config = {
     name: config_name,
     description: config_description,
@@ -869,8 +866,7 @@ function fromPublic(publicConfigJson) {
     userEntities: userEntities,
     allEnums: allEnums,
     checkpointSequence: config_checkpointSequence,
-    envioInfo: config_envioInfo,
-    subgraph: config_subgraph
+    envioInfo: config_envioInfo
   };
   let chainIds = publicConfig.isolatedChains;
   if (chainIds !== undefined) {

package/src/Core.res

@@ -28,17 +28,8 @@ type fromUserApiResult = {
   indexerCode: Null.t<string>,
 }
 
-type fromSubgraphOptions = {
-  name?: string,
-  env?: dict<string>,
-  files?: dict<string>,
-  root?: string,
-}
-
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
-  fromSubgraph: (string, string, fromSubgraphOptions) => fromUserApiResult,
-  subgraphFileToJavascript: (string, string) => string,
   encodeIndexedTopic: (~abiType: string, ~value: unknown) => EvmTypes.Hex.t,
   isSvmPubkey: (~value: string) => bool,
   fromUserApi: (string, fromUserApiOptions) => fromUserApiResult,
@@ -314,18 +305,6 @@ let fromUserApi = (~schema=?, ~env=?, ~files=?, ~withIndexerTypes=false, yaml) =
   )
 }
 
-/// Parses a subgraph project without touching the filesystem: subgraph.yaml and
-/// its schema inline, ABI bodies through `files`.
-let fromSubgraph = (~name=?, ~env=?, ~files=?, ~root=?, ~manifest, ~schema) => {
-  let addon = getAddon()
-  addon.fromSubgraph(manifest, schema, {?name, ?env, ?files, ?root})
-}
-
-let subgraphFileToJavascript = (~source, ~path) => {
-  let addon = getAddon()
-  addon.subgraphFileToJavascript(source, path)
-}
-
 let runCli = args => {
   let addon = getAddon()
   addon.runCli(~args, ~envioPackageDir=Null.make(envioPackageDir))

package/src/Core.res.mjs

@@ -232,21 +232,6 @@ function fromUserApi(schema, env, files, withIndexerTypesOpt, yaml) {
   });
 }
 
-function fromSubgraph(name, env, files, root, manifest, schema) {
-  let addon = getAddon();
-  return addon.fromSubgraph(manifest, schema, {
-    name: name,
-    env: env,
-    files: files,
-    root: root
-  });
-}
-
-function subgraphFileToJavascript(source, path) {
-  let addon = getAddon();
-  return addon.subgraphFileToJavascript(source, path);
-}
-
 function runCli(args) {
   let addon = getAddon();
   return addon.runCli(args, envioPackageDir);
@@ -268,8 +253,6 @@ export {
   getAddon,
   getConfigJson,
   fromUserApi,
-  fromSubgraph,
-  subgraphFileToJavascript,
   runCli,
 }
 /* envioPackageDir Not a pure module */

package/src/EventProcessing.res

@@ -51,7 +51,7 @@ let runEventHandlerOrThrow = async (
       isPreload: false,
       chains,
       config,
-      sync: UserContext.makeSyncState(),
+      isResolved: false,
     }
     await handler(
       (
@@ -61,7 +61,7 @@ let runEventHandlerOrThrow = async (
         }: Internal.handlerArgs
       ),
     )
-    contextParams.sync.status = Resolved
+    contextParams.isResolved = true
   } catch {
   | exn =>
     throw(
@@ -102,7 +102,7 @@ let runHandlerOrThrow = async (
         isPreload: false,
         chains,
         config,
-        sync: UserContext.makeSyncState(),
+        isResolved: false,
       }
       await handler(
         Ecosystem.makeOnBlockArgs(
@@ -111,7 +111,7 @@ let runHandlerOrThrow = async (
           ~context=UserContext.getHandlerContext(contextParams),
         ),
       )
-      contextParams.sync.status = Resolved
+      contextParams.isResolved = true
     } catch {
     | exn =>
       throw(
@@ -186,7 +186,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  sync: UserContext.makeSyncState(),
+                  isResolved: false,
                   config,
                 }),
               })
@@ -221,7 +221,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  sync: UserContext.makeSyncState(),
+                  isResolved: false,
                   config,
                 }),
               )

package/src/EventProcessing.res.mjs

@@ -38,7 +38,6 @@ let ProcessingError = /* @__PURE__ */Primitive_exceptions.create("EventProcessin
 async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config) {
   let timeBeforeHandler = Performance.now();
   try {
-    let contextParams_sync = UserContext.makeSyncState();
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
@@ -48,13 +47,13 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
       isPreload: false,
       chains: chains,
       config: config,
-      sync: contextParams_sync
+      isResolved: false
     };
     await handler({
       event: Ecosystem.getItemEvent(item, config.ecosystem),
       context: UserContext.getHandlerContext(contextParams)
     });
-    contextParams_sync.status = "Resolved";
+    contextParams.isResolved = true;
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
@@ -80,7 +79,6 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
     }
   }
   try {
-    let contextParams_sync = UserContext.makeSyncState();
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
@@ -90,10 +88,10 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
       isPreload: false,
       chains: chains,
       config: config,
-      sync: contextParams_sync
+      isResolved: false
     };
     await item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
-    contextParams_sync.status = "Resolved";
+    contextParams.isResolved = true;
     return;
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -135,7 +133,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
                 isPreload: true,
                 chains: chains,
                 config: config,
-                sync: UserContext.makeSyncState()
+                isResolved: false
               })
             }).then(() => IndexerState.endPreloadHandler(indexerState, timerRef, contractName, eventName))));
           } catch (exn) {
@@ -153,7 +151,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
             isPreload: true,
             chains: chains,
             config: config,
-            sync: UserContext.makeSyncState()
+            isResolved: false
           })))));
         } catch (exn$1) {
           

package/src/HandlerLoader.res

@@ -54,8 +54,8 @@ let registerContractHandlers = async (~contractName, ~handler: option<string>) =
   }
 }
 
-let globAutoLoadFiles = async (~handlers) => {
-  let srcPattern = `./${handlers}/**/*.{js,mjs,ts}`
+let getAutoLoadFiles = async (~config: Config.t) => {
+  let srcPattern = `./${config.handlers}/**/*.{js,mjs,ts}`
   try {
     let iterator = globIterator(srcPattern)
     let files = await iterator->Utils.Array.fromAsyncIterator
@@ -77,23 +77,6 @@ let globAutoLoadFiles = async (~handlers) => {
   }
 }
 
-let getAutoLoadFiles = async (~config: Config.t) =>
-  switch config.subgraph {
-  // A subgraph project's `src/` holds AssemblyScript mappings, not envio
-  // handlers: auto-loading or type-checking them as TypeScript would fail.
-  | Some(_) => []
-  | None => await globAutoLoadFiles(~handlers=config.handlers)
-  }
-
-type typeCheckResult = {
-  skipped?: string,
-  errors?: string,
-}
-
-@module("./HandlerTypeCheck.mjs")
-external checkTypesInWorker: (~cwd: string, ~files: array<string>) => promise<typeCheckResult> =
-  "check"
-
 let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
   // A contract's `handler:` may also be an auto-loaded file.
   let files =
@@ -104,10 +87,13 @@ let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
     ->Utils.Set.fromArray
     ->Utils.Set.toArray
   if files->Array.length > 0 {
-    switch await checkTypesInWorker(~cwd=NodeJs.Process.cwd(), ~files) {
-    | {errors} => JsError.throwWithMessage(`Handler files have type errors:\n\n${errors}`)
-    | {skipped} => Logging.warn(skipped)
-    | _ => ()
+    switch await HandlerTypeCheck.check(~cwd=NodeJs.Process.cwd(), ~files) {
+    | TypeErrors(errors) =>
+      JsError.throwWithMessage(
+        `The handler type check found errors. Fix them to start the indexer:\n\n${errors}`,
+      )
+    | Skipped(warning) => Logging.warn(warning)
+    | Passed => ()
     }
   }
 }
@@ -117,12 +103,6 @@ let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
 // `HandlerRegister.finishRegistration`. This loads the user handler files
 // (populating the global `HandlerRegister` registry as a side effect) and
 // returns the resulting per-chain registrations.
-// The subgraph runtime lives in this package but is never exported: it's
-// reached only from here, when the resolved config carries a translated
-// manifest.
-let registerSubgraph: (JSON.t, ~isDev: bool) => promise<unit> = %raw(`(subgraph, isDev) =>
-  import("./subgraph/runtime.ts").then((m) => m.registerSubgraph({ ...subgraph, isDev }))`)
-
 let registerAllHandlers = async (
   ~config: Config.t,
   ~autoLoadFiles,
@@ -130,27 +110,21 @@ let registerAllHandlers = async (
   HandlerRegister.startRegistration(~config)
   registerTsHooks()
 
-  switch config.subgraph {
-  // Registered after the TypeScript hooks, so the subgraph runtime's own hooks
-  // see a mapping first.
-  | Some(subgraph) => await registerSubgraph(subgraph, ~isDev=config.isDev)
-  | None =>
-    let _ = await autoLoadFiles
-    ->Array.map(file => {
-      importHandler(file)->Promise.catch(exn => {
-        let cause = exn->Utils.prettifyExn->Obj.magic
-        Logging.errorWithExn(exn, `Failed to auto-load handler file: ${file}`)
-        JsError.throwWithMessage(`Failed to auto-load handler file: ${file}. Cause: ${cause}`)
-      })
+  let _ = await autoLoadFiles
+  ->Array.map(file => {
+    importHandler(file)->Promise.catch(exn => {
+      let cause = exn->Utils.prettifyExn->Obj.magic
+      Logging.errorWithExn(exn, `Failed to auto-load handler file: ${file}`)
+      JsError.throwWithMessage(`Failed to auto-load handler file: ${file}. Cause: ${cause}`)
     })
-    ->Promise.all
+  })
+  ->Promise.all
 
-    let _ = await config.contractHandlers
-    ->Array.map(({name, handler}) => {
-      registerContractHandlers(~contractName=name, ~handler)
-    })
-    ->Promise.all
-  }
+  let _ = await config.contractHandlers
+  ->Array.map(({name, handler}) => {
+    registerContractHandlers(~contractName=name, ~handler)
+  })
+  ->Promise.all
 
   HandlerRegister.finishRegistration(~config)
 }

package/src/HandlerLoader.res.mjs

@@ -10,10 +10,10 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
+import * as HandlerTypeCheck from "./HandlerTypeCheck.res.mjs";
 import * as Promises from "node:fs/promises";
 import * as TsModuleHooksMjs from "./TsModuleHooks.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as HandlerTypeCheckMjs from "./HandlerTypeCheck.mjs";
 
 function registerTsHooksWith(prim) {
   TsModuleHooksMjs.register(prim);
@@ -58,8 +58,8 @@ async function registerContractHandlers(contractName, handler) {
   }
 }
 
-async function globAutoLoadFiles(handlers) {
-  let srcPattern = `./` + handlers + `/**/*.{js,mjs,ts}`;
+async function getAutoLoadFiles(config) {
+  let srcPattern = `./` + config.handlers + `/**/*.{js,mjs,ts}`;
   try {
     let iterator = Promises.glob(srcPattern);
     let files = await Utils.$$Array.fromAsyncIterator(iterator);
@@ -70,53 +70,30 @@ async function globAutoLoadFiles(handlers) {
   }
 }
 
-async function getAutoLoadFiles(config) {
-  let match = config.subgraph;
-  if (match !== undefined) {
-    return [];
-  } else {
-    return await globAutoLoadFiles(config.handlers);
-  }
-}
-
-function checkTypesInWorker(prim0, prim1) {
-  return HandlerTypeCheckMjs.check(prim0, prim1);
-}
-
 async function typeCheck(config, autoLoadFiles) {
   let files = Array.from(new Set(autoLoadFiles.concat(Stdlib_Array.filterMap(config.contractHandlers, param => param.handler)).filter(isTypeScript).map(toAbsolutePath)));
   if (files.length === 0) {
     return;
   }
-  let match = await HandlerTypeCheckMjs.check(Process.cwd(), files);
-  let skipped = match.skipped;
-  let errors = match.errors;
-  if (errors !== undefined) {
-    return Stdlib_JsError.throwWithMessage(`Handler files have type errors:\n\n` + errors);
-  } else if (skipped !== undefined) {
-    return Logging.warn(skipped);
-  } else {
+  let errors = await HandlerTypeCheck.check(Process.cwd(), files);
+  if (typeof errors !== "object") {
     return;
+  } else if (errors.TAG === "TypeErrors") {
+    return Stdlib_JsError.throwWithMessage(`The handler type check found errors. Fix them to start the indexer:\n\n` + errors._0);
+  } else {
+    return Logging.warn(errors._0);
   }
 }
 
-let registerSubgraph = ((subgraph, isDev) =>
-  import("./subgraph/runtime.ts").then((m) => m.registerSubgraph({ ...subgraph, isDev })));
-
 async function registerAllHandlers(config, autoLoadFiles) {
   HandlerRegister.startRegistration(config);
   registerTsHooks();
-  let subgraph = config.subgraph;
-  if (subgraph !== undefined) {
-    await registerSubgraph(subgraph, config.isDev);
-  } else {
-    await Promise.all(autoLoadFiles.map(file => Stdlib_Promise.$$catch(importHandler(file), exn => {
-      let cause = Utils.prettifyExn(exn);
-      Logging.errorWithExn(exn, `Failed to auto-load handler file: ` + file);
-      return Stdlib_JsError.throwWithMessage(`Failed to auto-load handler file: ` + file + `. Cause: ` + cause);
-    })));
-    await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
-  }
+  await Promise.all(autoLoadFiles.map(file => Stdlib_Promise.$$catch(importHandler(file), exn => {
+    let cause = Utils.prettifyExn(exn);
+    Logging.errorWithExn(exn, `Failed to auto-load handler file: ` + file);
+    return Stdlib_JsError.throwWithMessage(`Failed to auto-load handler file: ` + file + `. Cause: ` + cause);
+  })));
+  await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
   return HandlerRegister.finishRegistration(config);
 }
 
@@ -127,11 +104,8 @@ export {
   toAbsolutePath,
   importHandler,
   registerContractHandlers,
-  globAutoLoadFiles,
   getAutoLoadFiles,
-  checkTypesInWorker,
   typeCheck,
-  registerSubgraph,
   registerAllHandlers,
 }
 /* url Not a pure module */