envio 3.14.0-subgraph → 3.14.1

package/src/HandlerTypeCheck.res

@@ -0,0 +1,207 @@
+type result =
+  | Passed
+  | TypeErrors(string)
+  | Skipped(string)
+
+let timeoutSeconds = 30
+
+// tsc's pretty output reads the same from TypeScript 5 to 7: a diagnostic
+// starts unindented with its location, its code frame and related locations
+// follow indented, and `--listFiles` prints the program's files after the
+// last one, before the closing summary.
+let fileDiagnostic = /^(.+):\d+:\d+ - error TS(\d+): /
+let globalDiagnostic = /^error TS(\d+): /
+let summary = /^Found \d+ errors?\b/
+let thrownError = /^\w*Error: /
+
+let lines = output => output->String.replaceAll("\r\n", "\n")->String.split("\n")
+
+let rec findUp = (directory, name) => {
+  let candidate = NodeJs.Path.resolve([directory, name])->NodeJs.Path.toString
+  if NodeJs.Fs.existsSync(candidate) {
+    Some(candidate)
+  } else {
+    let parent = NodeJs.Path.dirname(directory)->NodeJs.Path.toString
+    parent === directory ? None : findUp(parent, name)
+  }
+}
+
+// The `tsc` the project's own scripts run. TypeScript 7 has no JavaScript API
+// to call instead, only this command.
+let resolveTsc = (~cwd) =>
+  try {
+    let manifest =
+      NodeJs.Module.createRequire(
+        NodeJs.Path.resolve([cwd, "package.json"])->NodeJs.Path.toString,
+      )->NodeJs.Module.resolve("typescript/package.json")
+    let bin = switch NodeJs.Fs.readFileSync(manifest)->JSON.parseOrThrow {
+    | JSON.Object(fields) =>
+      switch fields->Dict.get("bin") {
+      | Some(JSON.String(bin)) => Some(bin)
+      | Some(JSON.Object(bins)) =>
+        switch bins->Dict.get("tsc") {
+        | Some(JSON.String(bin)) => Some(bin)
+        | _ => None
+        }
+      | _ => None
+      }
+    | _ => None
+    }
+    bin->Option.map(bin =>
+      NodeJs.Path.resolve([
+        NodeJs.Path.dirname(manifest)->NodeJs.Path.toString,
+        bin,
+      ])->NodeJs.Path.toString
+    )
+  } catch {
+  | _ => None
+  }
+
+type run = {error: option<NodeJs.ChildProcess.execFileError>, output: string}
+
+let runTsc = (~tsc, ~cwd, args) =>
+  Promise.make((resolve, _) =>
+    NodeJs.ChildProcess.execFile(
+      NodeJs.Process.process->NodeJs.Process.execPath,
+      [tsc]->Array.concat(args),
+      {cwd, timeout: timeoutSeconds * 1000, maxBuffer: Float.Constants.positiveInfinity},
+      (error, stdout, stderr) =>
+        resolve({
+          error: error->Null.toOption,
+          output: NodeJs.Util.stripVTControlCharacters(stdout ++ stderr),
+        }),
+    )
+  )
+
+type diagnostic = {file: option<string>, code: int, lines: array<string>}
+
+// tsc type-checks nothing after a syntax error, an options error or a global
+// error, and an options error is reported at its line in tsconfig.json.
+let canStopTypeChecking = ({file, code}) =>
+  file->Option.isNone || code < 2000 || (code >= 5000 && code < 7000)
+
+// Paths compare relative to the project, which on Windows also ignores the
+// case of a drive letter tsc may print differently.
+let parse = (output, ~cwd) => {
+  let relative = file =>
+    NodeJs.Path.relative(cwd, NodeJs.Path.resolve([cwd, file])->NodeJs.Path.toString)
+  let diagnostics = []
+  let programFiles = Utils.Set.make()
+  let current = ref(None)
+  let start = (~file, ~code, line) => {
+    let diagnostic = {
+      file,
+      code: code->Int.fromString->Option.getOr(0),
+      lines: [line],
+    }
+    diagnostics->Array.push(diagnostic)
+    current := Some(diagnostic)
+  }
+  output
+  ->lines
+  ->Array.forEach(line =>
+    switch (
+      fileDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+      globalDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+    ) {
+    | (Some([Some(file), Some(code)]), _) => start(~file=Some(relative(file)), ~code, line)
+    | (_, Some([Some(code)])) => start(~file=None, ~code, line)
+    | _ if NodeJs.Path.isAbsolute(line) =>
+      programFiles->Utils.Set.add(relative(line))->ignore
+      current := None
+    | _ if summary->RegExp.test(line) => current := None
+    | _ => current.contents->Option.forEach(diagnostic => diagnostic.lines->Array.push(line))
+    }
+  )
+  (diagnostics, programFiles)
+}
+
+// Exit codes say nothing here: TypeScript 5 and 6 exit with 2 on type errors,
+// 7 with 1, and 1 is also how its launcher fails when the native compiler
+// isn't installed.
+let failure = ({error, output}) =>
+  switch error {
+  | Some({killed: true}) =>
+    `Skipped the handler type check: tsc didn't finish within ${timeoutSeconds->Int.toString} seconds.`
+  | _ =>
+    let reason =
+      output
+      ->lines
+      ->Array.find(line => thrownError->RegExp.test(line))
+      ->Option.getOr(output->String.trim)
+    `Skipped the handler type check: tsc failed to run:\n\n${reason}`
+  }
+
+let check = async (~cwd, ~files) => {
+  // The ReScript compiler checks a ReScript project's handlers, so it has no
+  // reason to set up TypeScript, and the warning would only be noise there.
+  // `rescript.json` at the root is what makes codegen treat it as ReScript.
+  let skip = warning =>
+    NodeJs.Fs.existsSync(NodeJs.Path.resolve([cwd, "rescript.json"])->NodeJs.Path.toString)
+      ? Passed
+      : Skipped(warning)
+
+  switch (resolveTsc(~cwd), findUp(cwd, "tsconfig.json")) {
+  | (None, _) =>
+    skip(
+      "Skipped the handler type check: typescript isn't installed. Add it to devDependencies to type-check handlers on start.",
+    )
+  | (_, None) =>
+    skip(
+      "Skipped the handler type check: no tsconfig.json found. Add one, like the one envio init creates, to type-check handlers on start.",
+    )
+  | (Some(tsc), Some(tsconfig)) =>
+    // The project's own `tsc --noEmit`, minus the build info it would write.
+    // `explainFiles` would replace the listed files' absolute paths with
+    // relative ones and the reasons each is included.
+    let run = await runTsc(
+      ~tsc,
+      ~cwd,
+      [
+        "--project",
+        tsconfig,
+        "--noEmit",
+        "--incremental",
+        "false",
+        "--composite",
+        "false",
+        "--listFiles",
+        "--explainFiles",
+        "false",
+        "--pretty",
+      ],
+    )
+    let (diagnostics, programFiles) = run.output->parse(~cwd)
+    let report = diagnostics =>
+      diagnostics
+      ->Array.map(({lines}) => lines->Array.join("\n")->String.trimEnd)
+      ->Array.join("\n\n")
+    let handlers = files->Array.map(file => NodeJs.Path.relative(cwd, file))
+    let isHandler = ({file}) => file->Option.mapOr(false, file => handlers->Array.includes(file))
+    let errors = diagnostics->Array.filter(isHandler)
+    let stopping =
+      diagnostics->Array.filter(diagnostic =>
+        !isHandler(diagnostic) && canStopTypeChecking(diagnostic)
+      )
+    let unchecked = handlers->Array.filter(file => !(programFiles->Utils.Set.has(file)))
+    if run.error->Option.isSome && diagnostics->Array.length === 0 {
+      Skipped(failure(run))
+    } else if errors->Array.length > 0 {
+      TypeErrors(report(errors))
+    } else if stopping->Array.length > 0 {
+      let reason = report(stopping)
+      Skipped(
+        `Skipped the handler type check: tsc can't check the handlers until these errors are fixed:\n\n${reason}`,
+      )
+    } else if unchecked->Array.length > 0 {
+      let names = unchecked->Array.join(", ")
+      let tsconfig = NodeJs.Path.relative(cwd, tsconfig)
+      let pronoun = unchecked->Array.length === 1 ? "it" : "them"
+      Skipped(
+        `Skipped the handler type check: ${tsconfig} doesn't include ${names}. Add ${pronoun} to "include" to type-check ${pronoun} on start.`,
+      )
+    } else {
+      Passed
+    }
+  }
+}

package/src/HandlerTypeCheck.res.mjs

@@ -0,0 +1,262 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Path from "path";
+import * as Util from "util";
+import * as Module from "module";
+import * as Process from "process";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Child_process from "child_process";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let fileDiagnostic = /^(.+):\d+:\d+ - error TS(\d+): /;
+
+let globalDiagnostic = /^error TS(\d+): /;
+
+let summary = /^Found \d+ errors?\b/;
+
+let thrownError = /^\w*Error: /;
+
+function lines(output) {
+  return output.replaceAll("\r\n", "\n").split("\n");
+}
+
+function findUp(_directory, name) {
+  while (true) {
+    let directory = _directory;
+    let candidate = Path.resolve(directory, name);
+    if (Fs.existsSync(candidate)) {
+      return candidate;
+    }
+    let parent = Path.dirname(directory);
+    if (parent === directory) {
+      return;
+    }
+    _directory = parent;
+    continue;
+  };
+}
+
+function resolveTsc(cwd) {
+  try {
+    let manifest = Module.createRequire(Path.resolve(cwd, "package.json")).resolve("typescript/package.json");
+    let fields = JSON.parse(Fs.readFileSync(manifest, "utf8"));
+    let bin;
+    if (typeof fields === "object" && fields !== null && !Array.isArray(fields)) {
+      let match = fields["bin"];
+      if (match !== undefined && !(match === null || Array.isArray(match))) {
+        switch (typeof match) {
+          case "string" :
+            bin = match;
+            break;
+          case "object" :
+            let match$1 = match["tsc"];
+            bin = typeof match$1 === "string" ? match$1 : undefined;
+            break;
+          default:
+            bin = undefined;
+        }
+      } else {
+        bin = undefined;
+      }
+    } else {
+      bin = undefined;
+    }
+    return Stdlib_Option.map(bin, bin => Path.resolve(Path.dirname(manifest), bin));
+  } catch (exn) {
+    return;
+  }
+}
+
+function runTsc(tsc, cwd, args) {
+  return new Promise((resolve, param) => {
+    Child_process.execFile(Process.execPath, [tsc].concat(args), {
+      cwd: cwd,
+      timeout: 30000,
+      maxBuffer: Number.POSITIVE_INFINITY
+    }, (error, stdout, stderr) => resolve({
+      error: error === null ? undefined : Primitive_option.some(error),
+      output: Util.stripVTControlCharacters(stdout + stderr)
+    }));
+  });
+}
+
+function canStopTypeChecking(param) {
+  let code = param.code;
+  if (Stdlib_Option.isNone(param.file) || code < 2000) {
+    return true;
+  } else if (code >= 5000) {
+    return code < 7000;
+  } else {
+    return false;
+  }
+}
+
+function parse(output, cwd) {
+  let relative = file => Path.relative(cwd, Path.resolve(cwd, file));
+  let diagnostics = [];
+  let programFiles = new Set();
+  let current = {
+    contents: undefined
+  };
+  let start = (file, code, line) => {
+    let diagnostic_code = Stdlib_Option.getOr(Stdlib_Int.fromString(code, undefined), 0);
+    let diagnostic_lines = [line];
+    let diagnostic = {
+      file: file,
+      code: diagnostic_code,
+      lines: diagnostic_lines
+    };
+    diagnostics.push(diagnostic);
+    current.contents = diagnostic;
+  };
+  lines(output).forEach(line => {
+    let match = Stdlib_Option.map(Primitive_option.fromNullable(fileDiagnostic.exec(line)), prim => prim.slice(1));
+    let match$1 = Stdlib_Option.map(Primitive_option.fromNullable(globalDiagnostic.exec(line)), prim => prim.slice(1));
+    let exit = 0;
+    if (match !== undefined && match.length === 2) {
+      let file = match[0];
+      if (file !== undefined) {
+        let code = match[1];
+        if (code !== undefined) {
+          return start(relative(file), code, line);
+        }
+        exit = 2;
+      } else {
+        exit = 2;
+      }
+    } else {
+      exit = 2;
+    }
+    if (exit === 2 && match$1 !== undefined && match$1.length === 1) {
+      let code$1 = match$1[0];
+      if (code$1 !== undefined) {
+        return start(undefined, code$1, line);
+      }
+    }
+    if (Path.isAbsolute(line)) {
+      programFiles.add(relative(line));
+      current.contents = undefined;
+      return;
+    } else if (summary.test(line)) {
+      current.contents = undefined;
+      return;
+    } else {
+      return Stdlib_Option.forEach(current.contents, diagnostic => {
+        diagnostic.lines.push(line);
+      });
+    }
+  });
+  return [
+    diagnostics,
+    programFiles
+  ];
+}
+
+function failure(param) {
+  let output = param.output;
+  let error = param.error;
+  if (error !== undefined && error.killed) {
+    return `Skipped the handler type check: tsc didn't finish within ` + (30).toString() + ` seconds.`;
+  }
+  let reason = Stdlib_Option.getOr(lines(output).find(line => thrownError.test(line)), output.trim());
+  return `Skipped the handler type check: tsc failed to run:\n\n` + reason;
+}
+
+async function check(cwd, files) {
+  let skip = warning => {
+    if (Fs.existsSync(Path.resolve(cwd, "rescript.json"))) {
+      return "Passed";
+    } else {
+      return {
+        TAG: "Skipped",
+        _0: warning
+      };
+    }
+  };
+  let match = resolveTsc(cwd);
+  let match$1 = findUp(cwd, "tsconfig.json");
+  if (match === undefined) {
+    return skip("Skipped the handler type check: typescript isn't installed. Add it to devDependencies to type-check handlers on start.");
+  }
+  if (match$1 === undefined) {
+    return skip("Skipped the handler type check: no tsconfig.json found. Add one, like the one envio init creates, to type-check handlers on start.");
+  }
+  let run = await runTsc(match, cwd, [
+    "--project",
+    match$1,
+    "--noEmit",
+    "--incremental",
+    "false",
+    "--composite",
+    "false",
+    "--listFiles",
+    "--explainFiles",
+    "false",
+    "--pretty"
+  ]);
+  let match$2 = parse(run.output, cwd);
+  let programFiles = match$2[1];
+  let diagnostics = match$2[0];
+  let report = diagnostics => diagnostics.map(param => param.lines.join("\n").trimEnd()).join("\n\n");
+  let handlers = files.map(file => Path.relative(cwd, file));
+  let isHandler = param => Stdlib_Option.mapOr(param.file, false, file => handlers.includes(file));
+  let errors = diagnostics.filter(isHandler);
+  let stopping = diagnostics.filter(diagnostic => {
+    if (isHandler(diagnostic)) {
+      return false;
+    } else {
+      return canStopTypeChecking(diagnostic);
+    }
+  });
+  let unchecked = handlers.filter(file => !programFiles.has(file));
+  if (Stdlib_Option.isSome(run.error) && diagnostics.length === 0) {
+    return {
+      TAG: "Skipped",
+      _0: failure(run)
+    };
+  }
+  if (errors.length !== 0) {
+    return {
+      TAG: "TypeErrors",
+      _0: report(errors)
+    };
+  }
+  if (stopping.length !== 0) {
+    let reason = report(stopping);
+    return {
+      TAG: "Skipped",
+      _0: `Skipped the handler type check: tsc can't check the handlers until these errors are fixed:\n\n` + reason
+    };
+  }
+  if (unchecked.length === 0) {
+    return "Passed";
+  }
+  let names = unchecked.join(", ");
+  let tsconfig = Path.relative(cwd, match$1);
+  let pronoun = unchecked.length === 1 ? "it" : "them";
+  return {
+    TAG: "Skipped",
+    _0: `Skipped the handler type check: ` + tsconfig + ` doesn't include ` + names + `. Add ` + pronoun + ` to "include" to type-check ` + pronoun + ` on start.`
+  };
+}
+
+let timeoutSeconds = 30;
+
+export {
+  timeoutSeconds,
+  fileDiagnostic,
+  globalDiagnostic,
+  summary,
+  thrownError,
+  lines,
+  findUp,
+  resolveTsc,
+  runTsc,
+  canStopTypeChecking,
+  parse,
+  failure,
+  check,
+}
+/* fs Not a pure module */

package/src/LoadLayer.res

@@ -332,44 +332,6 @@ let loadEffect = (
   )
 }
 
-// Keying an _in walks every value, so it's computed once and handed on rather
-// than recomputed by each reader. Before answering "not in memory", the rows
-// already loaded for other filters are checked: they may cover this one.
-let indexFilter = (inMemTable, ~filter, ~table) => {
-  let filterKey = filter->EntityFilter.toString(~table)
-  if !(inMemTable->InMemoryTable.Entity.hasIndex)(filterKey) {
-    inMemTable->InMemoryTable.Entity.tryIndexFromLoadedValues(~filter, ~table)
-  }
-  filterKey
-}
-
-// A recorded absence is an answer too: `Some(None)` means the entity is known
-// not to exist, so no load is needed to say so.
-let getByIdInMemory = (
-  ~entityConfig: Internal.entityConfig,
-  ~scope,
-  ~indexerState,
-  ~entityId: string,
-) => {
-  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  inMemTable.latestEntityChangeById->Dict.has(entityId)
-    ? Some((inMemTable->InMemoryTable.Entity.getUnsafe)(entityId))
-    : None
-}
-
-let getByFilterInMemory = (
-  ~entityConfig: Internal.entityConfig,
-  ~scope,
-  ~indexerState,
-  ~filter: EntityFilter.t,
-) => {
-  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  let filterKey = inMemTable->indexFilter(~filter, ~table=entityConfig.table)
-  (inMemTable->InMemoryTable.Entity.hasIndex)(filterKey)
-    ? Some((inMemTable->InMemoryTable.Entity.getUnsafeOnIndex)(filterKey))
-    : None
-}
-
 let loadByParsedFilter = (
   ~loadManager,
   ~persistence: Persistence.t,
@@ -463,7 +425,13 @@ let loadByParsedFilter = (
     )
   }
 
-  let filterKey = inMemTable->indexFilter(~filter, ~table=entityConfig.table)
+  // Keying an _in walks every value, so it's computed once here and handed to
+  // the load manager rather than recomputed by the hasher.
+  let filterKey = filter->EntityFilter.toString(~table=entityConfig.table)
+
+  if !(inMemTable->InMemoryTable.Entity.hasIndex)(filterKey) {
+    inMemTable->InMemoryTable.Entity.tryIndexFromLoadedValues(~filter, ~table=entityConfig.table)
+  }
 
   loadManager->LoadManager.call(
     ~key,

package/src/LoadLayer.res.mjs

@@ -15,7 +15,6 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -183,69 +182,46 @@ function loadEffect(loadManager, persistence, effect, effectArgs, scope, indexer
   return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => InMemoryStore.hasEffectOutput(inMemTable, hash), hash => InMemoryStore.getEffectOutputUnsafe(inMemTable, hash));
 }
 
-function indexFilter(inMemTable, filter, table) {
-  let filterKey = EntityFilter.toString(filter, table);
-  if (!InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
-    InMemoryTable.Entity.tryIndexFromLoadedValues(inMemTable, filter, table);
-  }
-  return filterKey;
-}
-
-function getByIdInMemory(entityConfig, scope, indexerState, entityId) {
-  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
-  if (entityId in inMemTable.latestEntityChangeById) {
-    return Primitive_option.some(InMemoryTable.Entity.getUnsafe(inMemTable)(entityId));
-  }
-}
-
-function getByFilterInMemory(entityConfig, scope, indexerState, filter) {
-  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
-  let filterKey = indexFilter(inMemTable, filter, entityConfig.table);
-  if (InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
-    return InMemoryTable.Entity.getUnsafeOnIndex(inMemTable)(filterKey);
-  }
-}
-
-function loadByParsedFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, filter) {
-  let key = EntityFilter.toOperationKey(filter, entityConfig.name) + scopeKeySuffix(scope);
-  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
-  let load = async (filters, param) => {
-    let storage = Persistence.getInitializedStorageOrThrow(persistence);
-    let timerRef = IndexerState.startStorageLoad(indexerState, storage.name, key);
-    let size = {
-      contents: 0
-    };
-    filters.forEach(filter => InMemoryTable.Entity.addEmptyIndex(inMemTable, filter, entityConfig.table));
-    await storage.ensureQueryIndexes(entityConfig, scope, filters);
-    let queries = EntityFilter.merge(filters);
-    await Promise.all(queries.map(async filter => {
-      try {
-        let entities = await storage.loadOrThrow(EntityFilter.scoped(filter, entityConfig.table, scope), entityConfig.table);
-        let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
-        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entity.id, entity));
-        InMemoryTable.Entity.recordLoadedValues(inMemTable, filter, entityConfig.table);
-        size.contents = size.contents + entities.length | 0;
-        return;
-      } catch (raw_exn) {
-        let exn = Primitive_exceptions.internalToException(raw_exn);
-        if (exn.RE_EXN_ID === Persistence.StorageError) {
-          return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Ecosystem.getItemLogger(item, ecosystem), {
-            operation: key,
-            params: EntityFilter.getParams(filter)
-          }), exn.message, exn.reason);
-        }
-        throw exn;
-      }
-    }));
-    return IndexerState.endStorageLoad(indexerState, timerRef, storage.name, key, Stdlib_Array.reduce(queries, 0, (acc, query) => acc + EntityFilter.valuesCount(query) | 0), size.contents);
-  };
-  let filterKey = indexFilter(inMemTable, filter, entityConfig.table);
-  return LoadManager.call(loadManager, filter, key, load, param => filterKey, shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable));
-}
-
 function loadByFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, filter) {
   try {
-    return loadByParsedFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table));
+    let filter$1 = EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table);
+    let key = EntityFilter.toOperationKey(filter$1, entityConfig.name) + scopeKeySuffix(scope);
+    let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
+    let load = async (filters, param) => {
+      let storage = Persistence.getInitializedStorageOrThrow(persistence);
+      let timerRef = IndexerState.startStorageLoad(indexerState, storage.name, key);
+      let size = {
+        contents: 0
+      };
+      filters.forEach(filter => InMemoryTable.Entity.addEmptyIndex(inMemTable, filter, entityConfig.table));
+      await storage.ensureQueryIndexes(entityConfig, scope, filters);
+      let queries = EntityFilter.merge(filters);
+      await Promise.all(queries.map(async filter => {
+        try {
+          let entities = await storage.loadOrThrow(EntityFilter.scoped(filter, entityConfig.table, scope), entityConfig.table);
+          let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
+          entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entity.id, entity));
+          InMemoryTable.Entity.recordLoadedValues(inMemTable, filter, entityConfig.table);
+          size.contents = size.contents + entities.length | 0;
+          return;
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          if (exn.RE_EXN_ID === Persistence.StorageError) {
+            return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Ecosystem.getItemLogger(item, ecosystem), {
+              operation: key,
+              params: EntityFilter.getParams(filter)
+            }), exn.message, exn.reason);
+          }
+          throw exn;
+        }
+      }));
+      return IndexerState.endStorageLoad(indexerState, timerRef, storage.name, key, Stdlib_Array.reduce(queries, 0, (acc, query) => acc + EntityFilter.valuesCount(query) | 0), size.contents);
+    };
+    let filterKey = EntityFilter.toString(filter$1, entityConfig.table);
+    if (!InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
+      InMemoryTable.Entity.tryIndexFromLoadedValues(inMemTable, filter$1, entityConfig.table);
+    }
+    return LoadManager.call(loadManager, filter$1, key, load, param => filterKey, shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable));
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return Promise.reject(Utils.prettifyExn(exn));
@@ -255,9 +231,6 @@ function loadByFilter(loadManager, persistence, entityConfig, scope, indexerStat
 export {
   loadById,
   loadByFilter,
-  loadByParsedFilter,
-  getByIdInMemory,
-  getByFilterInMemory,
   loadEffect,
 }
 /* Utils Not a pure module */

package/src/LoadLayer.resi

@@ -22,34 +22,6 @@ let loadByFilter: (
   ~filter: dict<dict<unknown>>,
 ) => promise<array<Internal.entity>>
 
-let loadByParsedFilter: (
-  ~loadManager: LoadManager.t,
-  ~persistence: Persistence.t,
-  ~entityConfig: Internal.entityConfig,
-  ~scope: Internal.chainScope,
-  ~indexerState: IndexerState.t,
-  ~shouldGroup: bool,
-  ~item: Internal.item,
-  ~ecosystem: Ecosystem.t,
-  ~filter: EntityFilter.t,
-) => promise<array<Internal.entity>>
-
-// What a get or getWhere answers without a load, or None when it would need
-// one. The sync context reads through these and suspends on None.
-let getByIdInMemory: (
-  ~entityConfig: Internal.entityConfig,
-  ~scope: Internal.chainScope,
-  ~indexerState: IndexerState.t,
-  ~entityId: string,
-) => option<option<Internal.entity>>
-
-let getByFilterInMemory: (
-  ~entityConfig: Internal.entityConfig,
-  ~scope: Internal.chainScope,
-  ~indexerState: IndexerState.t,
-  ~filter: EntityFilter.t,
-) => option<array<Internal.entity>>
-
 let loadEffect: (
   ~loadManager: LoadManager.t,
   ~persistence: Persistence.t,