@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/GraphQL_ServerInstance.res

@@ -0,0 +1,310 @@
+// GraphQL server instance factory.
+// Creates independent server instances with isolated registries.
+// Used by Platform to create separate core and plugin servers in split mode.
+
+module YG = GraphqlYoga
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type resolverFn = YG.resolverFn
+
+// graphql-ws WebSocket transport for subscriptions. Yoga's built-in
+// subscription transport is SSE-over-POST; clients using the graphql-ws
+// protocol (e.g. host-shell, AppSync clients in prod) need an explicit
+// WebSocket endpoint. We attach a `WebSocketServer` to the same HTTP server
+// and hand it to `graphql-ws/lib/use/ws::useServer` along with the live
+// schema, which fans out subscription events to connected sockets.
+type wsServer
+@new @module("ws")
+external newWebSocketServer: {"server": YG.httpServer, "path": string} => wsServer =
+  "WebSocketServer"
+@module("graphql-ws/lib/use/ws")
+external wsUseServer: ({"schema": YG.schema}, wsServer) => unit = "useServer"
+
+@val external processEnv: dict<string> = "process.env"
+let debug = processEnv->Dict.get("GRAPHQL_DEBUG")->Option.isSome
+
+type diagnostics = {
+  registeredTypeDefinitions: array<string>,
+  registeredMutationFields: array<string>,
+  registeredQueryFields: array<string>,
+  registeredMutationResolvers: array<string>,
+  registeredQueryResolvers: array<string>,
+  typeCount: int,
+  sdlMutationCount: int,
+  sdlQueryCount: int,
+  resolverMutationCount: int,
+  resolverQueryCount: int,
+  mismatches: array<string>,
+  fullSdl: option<string>,
+  serverRunning: bool,
+}
+
+type t = {
+  registerMutations: (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => unit,
+  registerQueries: (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => unit,
+  registerSubscriptions: (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => unit,
+  registerTypes: (~sdlTypes: array<string>) => unit,
+  getMutationResolver: string => option<resolverFn>,
+  getQueryResolver: string => option<resolverFn>,
+  // `~contextFactory` is the yoga context factory — when supplied, requests
+  // run through it so resolvers see `ctx.identity`. Omit (or pass None) for
+  // unauthenticated servers. In-memory `Platform.res` wires
+  // `Auth_GraphqlContext.buildAuthContext` here so the admin server enforces
+  // the same bearer-token rules as the data server instead of leaving
+  // Platform_* queries / mutations wide open.
+  start: (~port: int=?, ~contextFactory: YG.contextFactory=?, unit) => unit,
+  stop: unit => unit,
+  reset: unit => unit,
+  buildSdl: unit => string,
+  getFullSdl: unit => option<string>,
+  getSchema: unit => option<YG.schema>,
+  diagnostics: unit => diagnostics,
+  printDiagnostics: unit => unit,
+}
+
+let extractFieldName = (sdlField: string): string => {
+  let trimmed = sdlField->String.trim
+  trimmed
+  ->String.split("(")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
+  ->String.split(":")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
+}
+
+let make = (~label: string="GraphQL"): t => {
+  let mutationResolvers: ref<dict<resolverFn>> = ref(Dict.make())
+  let queryResolvers: ref<dict<resolverFn>> = ref(Dict.make())
+  let subscriptionResolvers: ref<dict<resolverFn>> = ref(Dict.make())
+  let mutationFields: ref<array<string>> = ref([])
+  let queryFields: ref<array<string>> = ref([])
+  let subscriptionFields: ref<array<string>> = ref([])
+  let typeDefinitions: ref<array<string>> = ref([])
+  let activeServer: ref<option<YG.httpServer>> = ref(None)
+  let activeSchema: ref<option<YG.schema>> = ref(None)
+  let lastFullSdl: ref<option<string>> = ref(None)
+
+  let registerMutations = (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => {
+    mutationFields.contents = mutationFields.contents->Array.concat(sdlFields)
+    resolvers->Dict.toArray->Array.forEach(((k, v)) => mutationResolvers.contents->Dict.set(k, v))
+  }
+
+  let registerQueries = (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => {
+    queryFields.contents = queryFields.contents->Array.concat(sdlFields)
+    resolvers->Dict.toArray->Array.forEach(((k, v)) => queryResolvers.contents->Dict.set(k, v))
+  }
+
+  let registerSubscriptions = (~sdlFields: array<string>, ~resolvers: dict<resolverFn>) => {
+    subscriptionFields.contents = subscriptionFields.contents->Array.concat(sdlFields)
+    resolvers->Dict.toArray->Array.forEach(((k, v)) =>
+      subscriptionResolvers.contents->Dict.set(k, v)
+    )
+  }
+
+  let registerTypes = (~sdlTypes: array<string>) => {
+    typeDefinitions.contents = typeDefinitions.contents->Array.concat(sdlTypes)
+  }
+
+  let getMutationResolver = (fieldName: string): option<resolverFn> =>
+    mutationResolvers.contents->Dict.get(fieldName)
+
+  let getQueryResolver = (fieldName: string): option<resolverFn> =>
+    queryResolvers.contents->Dict.get(fieldName)
+
+  let buildSdl = () => {
+    let typesSdl =
+      typeDefinitions.contents->Array.length > 0
+        ? typeDefinitions.contents->Array.join("\n\n")
+        : ""
+    let mutations =
+      mutationFields.contents->Array.length > 0
+        ? mutationFields.contents->Array.join("\n")
+        : "  _noop: String"
+    let queries =
+      queryFields.contents->Array.length > 0
+        ? queryFields.contents->Array.join("\n")
+        : "  _noop: String"
+    let queriesMutationsSdl = `type Query {
+${queries}
+}
+type Mutation {
+${mutations}
+}`
+    let subscriptionsSdl =
+      subscriptionFields.contents->Array.length > 0
+        ? `\n\ntype Subscription {\n${subscriptionFields.contents->Array.join("\n")}\n}`
+        : ""
+    let base =
+      typesSdl->String.length > 0
+        ? typesSdl ++ "\n\n" ++ queriesMutationsSdl
+        : queriesMutationsSdl
+    base ++ subscriptionsSdl
+  }
+
+  let stop = () =>
+    switch activeServer.contents {
+    | Some(server) =>
+      server->YG.close(() => ())
+      activeServer.contents = None
+      activeSchema.contents = None
+    | None => ()
+    }
+
+  let start = (~port: int=4000, ~contextFactory: option<YG.contextFactory>=?, ()) => {
+    let resolvers = Dict.make()
+    resolvers->Dict.set("Query", queryResolvers.contents)
+    resolvers->Dict.set("Mutation", mutationResolvers.contents)
+    if subscriptionResolvers.contents->Dict.keysToArray->Array.length > 0 {
+      resolvers->Dict.set("Subscription", subscriptionResolvers.contents)
+    }
+    let sdl = buildSdl()
+    lastFullSdl.contents = Some(sdl)
+    let schema = YG.createSchema({"typeDefs": sdl, "resolvers": resolvers})
+    activeSchema.contents = Some(schema)
+    let yoga = switch contextFactory {
+    | Some(ctx) =>
+      YG.createYogaWithContext({
+        "schema": schema,
+        "graphiql": true,
+        "logging": debug,
+        "maskedErrors": !debug,
+        "context": ctx,
+      })
+    | None =>
+      YG.createYoga({
+        "schema": schema,
+        "graphiql": true,
+        "logging": debug,
+        "maskedErrors": !debug,
+      })
+    }
+    let server = YG.createServer(yoga)
+    server->YG.listen(port, () =>
+      log.info(~comp=label, `listening on http://localhost:${port->Int.toString}/graphql`)
+    )
+    if subscriptionResolvers.contents->Dict.keysToArray->Array.length > 0 {
+      let wss = newWebSocketServer({"server": server, "path": "/graphql"})
+      wsUseServer({"schema": schema}, wss)
+      log.info(~comp=label, `graphql-ws subscriptions on ws://localhost:${port->Int.toString}/graphql`)
+    }
+    activeServer.contents = Some(server)
+  }
+
+  let reset = () => {
+    mutationResolvers.contents = Dict.make()
+    queryResolvers.contents = Dict.make()
+    subscriptionResolvers.contents = Dict.make()
+    mutationFields.contents = []
+    queryFields.contents = []
+    subscriptionFields.contents = []
+    typeDefinitions.contents = []
+    activeSchema.contents = None
+    lastFullSdl.contents = None
+  }
+
+  let getFullSdl = () => lastFullSdl.contents
+  let getSchema = () => activeSchema.contents
+
+  let diagnostics = (): diagnostics => {
+    let mutFieldNames =
+      mutationFields.contents->Array.map(extractFieldName)->Array.filter(n => n != "_noop")
+    let queryFieldNames =
+      queryFields.contents->Array.map(extractFieldName)->Array.filter(n => n != "_noop")
+    let mutResolverNames = mutationResolvers.contents->Dict.keysToArray
+    let queryResolverNames = queryResolvers.contents->Dict.keysToArray
+
+    let mismatches: array<string> = []
+
+    let mutResolverSet = Set.fromArray(mutResolverNames)
+    mutFieldNames->Array.forEach(name =>
+      if !(mutResolverSet->Set.has(name)) {
+        mismatches->Array.push(`Mutation "${name}": SDL field but no resolver`)
+      }
+    )
+    let queryResolverSet = Set.fromArray(queryResolverNames)
+    queryFieldNames->Array.forEach(name =>
+      if !(queryResolverSet->Set.has(name)) {
+        mismatches->Array.push(`Query "${name}": SDL field but no resolver`)
+      }
+    )
+    let mutFieldSet = Set.fromArray(mutFieldNames)
+    mutResolverNames->Array.forEach(name =>
+      if !(mutFieldSet->Set.has(name)) {
+        mismatches->Array.push(`Mutation "${name}": resolver but no SDL field`)
+      }
+    )
+    let queryFieldSet = Set.fromArray(queryFieldNames)
+    queryResolverNames->Array.forEach(name =>
+      if !(queryFieldSet->Set.has(name)) {
+        mismatches->Array.push(`Query "${name}": resolver but no SDL field`)
+      }
+    )
+    let typeNames =
+      typeDefinitions.contents->Array.map(ReventlessCore.GraphQL_Stitcher.extractLeadingName)
+
+    {
+      registeredTypeDefinitions: typeNames,
+      registeredMutationFields: mutFieldNames,
+      registeredQueryFields: queryFieldNames,
+      registeredMutationResolvers: mutResolverNames,
+      registeredQueryResolvers: queryResolverNames,
+      typeCount: typeNames->Array.length,
+      sdlMutationCount: mutFieldNames->Array.length,
+      sdlQueryCount: queryFieldNames->Array.length,
+      resolverMutationCount: mutResolverNames->Array.length,
+      resolverQueryCount: queryResolverNames->Array.length,
+      mismatches,
+      fullSdl: lastFullSdl.contents,
+      serverRunning: activeServer.contents->Option.isSome,
+    }
+  }
+
+  let printDiagnostics = () => {
+    let p = s => log.info(~comp=label, s)
+    let d = diagnostics()
+    p("Diagnostics")
+    p(`  Types: ${d.typeCount->Int.toString}`)
+    p(
+      `  Mutations: ${d.sdlMutationCount->Int.toString} SDL fields, ${d.resolverMutationCount->Int.toString} resolvers`,
+    )
+    p(
+      `  Queries: ${d.sdlQueryCount->Int.toString} SDL fields, ${d.resolverQueryCount->Int.toString} resolvers`,
+    )
+    if d.mismatches->Array.length > 0 {
+      p(`  Mismatches (${d.mismatches->Array.length->Int.toString}):`)
+      d.mismatches->Array.forEach(m => p(`    - ${m}`))
+    } else {
+      p("  No mismatches")
+    }
+    p(`  Server running: ${d.serverRunning ? "yes" : "no"}`)
+    switch d.fullSdl {
+    | Some(sdl) =>
+      p("")
+      p("--- Full SDL ---")
+      sdl->String.split("\n")->Array.forEach(line => p(line))
+      p("--- End ---")
+    | None => p("  No SDL recorded")
+    }
+  }
+
+  {
+    registerMutations,
+    registerQueries,
+    registerSubscriptions,
+    registerTypes,
+    getMutationResolver,
+    getQueryResolver,
+    start,
+    stop,
+    reset,
+    buildSdl,
+    getFullSdl,
+    getSchema,
+    diagnostics,
+    printDiagnostics,
+  }
+}

package/src/adapter/GraphQL_ServerInstance.res.mjs

@@ -0,0 +1,257 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Ws from "ws";
+import * as Http from "http";
+import * as GraphqlYoga from "graphql-yoga";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Ws$1 from "graphql-ws/lib/use/ws";
+import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let debug = Stdlib_Option.isSome(process.env["GRAPHQL_DEBUG"]);
+
+function extractFieldName(sdlField) {
+  let trimmed = sdlField.trim();
+  return Stdlib_Option.getOr(Stdlib_Option.getOr(trimmed.split("(")[0], "").trim().split(":")[0], "").trim();
+}
+
+function make(labelOpt) {
+  let label = labelOpt !== undefined ? labelOpt : "GraphQL";
+  let mutationResolvers = {
+    contents: {}
+  };
+  let queryResolvers = {
+    contents: {}
+  };
+  let subscriptionResolvers = {
+    contents: {}
+  };
+  let mutationFields = {
+    contents: []
+  };
+  let queryFields = {
+    contents: []
+  };
+  let subscriptionFields = {
+    contents: []
+  };
+  let typeDefinitions = {
+    contents: []
+  };
+  let activeServer = {
+    contents: undefined
+  };
+  let activeSchema = {
+    contents: undefined
+  };
+  let lastFullSdl = {
+    contents: undefined
+  };
+  let registerMutations = (sdlFields, resolvers) => {
+    mutationFields.contents = mutationFields.contents.concat(sdlFields);
+    Object.entries(resolvers).forEach(param => {
+      mutationResolvers.contents[param[0]] = param[1];
+    });
+  };
+  let registerQueries = (sdlFields, resolvers) => {
+    queryFields.contents = queryFields.contents.concat(sdlFields);
+    Object.entries(resolvers).forEach(param => {
+      queryResolvers.contents[param[0]] = param[1];
+    });
+  };
+  let registerSubscriptions = (sdlFields, resolvers) => {
+    subscriptionFields.contents = subscriptionFields.contents.concat(sdlFields);
+    Object.entries(resolvers).forEach(param => {
+      subscriptionResolvers.contents[param[0]] = param[1];
+    });
+  };
+  let registerTypes = sdlTypes => {
+    typeDefinitions.contents = typeDefinitions.contents.concat(sdlTypes);
+  };
+  let getMutationResolver = fieldName => mutationResolvers.contents[fieldName];
+  let getQueryResolver = fieldName => queryResolvers.contents[fieldName];
+  let buildSdl = () => {
+    let typesSdl = typeDefinitions.contents.length !== 0 ? typeDefinitions.contents.join("\n\n") : "";
+    let mutations = mutationFields.contents.length !== 0 ? mutationFields.contents.join("\n") : "  _noop: String";
+    let queries = queryFields.contents.length !== 0 ? queryFields.contents.join("\n") : "  _noop: String";
+    let queriesMutationsSdl = `type Query {
+` + queries + `
+}
+type Mutation {
+` + mutations + `
+}`;
+    let subscriptionsSdl = subscriptionFields.contents.length !== 0 ? `\n\ntype Subscription {\n` + subscriptionFields.contents.join("\n") + `\n}` : "";
+    let base = typesSdl.length > 0 ? typesSdl + "\n\n" + queriesMutationsSdl : queriesMutationsSdl;
+    return base + subscriptionsSdl;
+  };
+  let stop = () => {
+    let server = activeServer.contents;
+    if (server !== undefined) {
+      Primitive_option.valFromOption(server).close(() => {});
+      activeServer.contents = undefined;
+      activeSchema.contents = undefined;
+      return;
+    }
+  };
+  let start = (portOpt, contextFactory, param) => {
+    let port = portOpt !== undefined ? portOpt : 4000;
+    let resolvers = {};
+    resolvers["Query"] = queryResolvers.contents;
+    resolvers["Mutation"] = mutationResolvers.contents;
+    if (Object.keys(subscriptionResolvers.contents).length !== 0) {
+      resolvers["Subscription"] = subscriptionResolvers.contents;
+    }
+    let sdl = buildSdl();
+    lastFullSdl.contents = sdl;
+    let schema = GraphqlYoga.createSchema({
+      typeDefs: sdl,
+      resolvers: resolvers
+    });
+    activeSchema.contents = Primitive_option.some(schema);
+    let yoga = contextFactory !== undefined ? GraphqlYoga.createYoga({
+        schema: schema,
+        graphiql: true,
+        logging: debug,
+        maskedErrors: !debug,
+        context: contextFactory
+      }) : GraphqlYoga.createYoga({
+        schema: schema,
+        graphiql: true,
+        logging: debug,
+        maskedErrors: !debug
+      });
+    let server = Http.createServer(yoga);
+    server.listen(port, () => log.info(label, undefined, `listening on http://localhost:` + port.toString() + `/graphql`));
+    if (Object.keys(subscriptionResolvers.contents).length !== 0) {
+      let wss = new Ws.WebSocketServer({
+        server: server,
+        path: "/graphql"
+      });
+      Ws$1.useServer({
+        schema: schema
+      }, wss);
+      log.info(label, undefined, `graphql-ws subscriptions on ws://localhost:` + port.toString() + `/graphql`);
+    }
+    activeServer.contents = Primitive_option.some(server);
+  };
+  let reset = () => {
+    mutationResolvers.contents = {};
+    queryResolvers.contents = {};
+    subscriptionResolvers.contents = {};
+    mutationFields.contents = [];
+    queryFields.contents = [];
+    subscriptionFields.contents = [];
+    typeDefinitions.contents = [];
+    activeSchema.contents = undefined;
+    lastFullSdl.contents = undefined;
+  };
+  let getFullSdl = () => lastFullSdl.contents;
+  let getSchema = () => activeSchema.contents;
+  let diagnostics = () => {
+    let mutFieldNames = mutationFields.contents.map(extractFieldName).filter(n => n !== "_noop");
+    let queryFieldNames = queryFields.contents.map(extractFieldName).filter(n => n !== "_noop");
+    let mutResolverNames = Object.keys(mutationResolvers.contents);
+    let queryResolverNames = Object.keys(queryResolvers.contents);
+    let mismatches = [];
+    let mutResolverSet = new Set(mutResolverNames);
+    mutFieldNames.forEach(name => {
+      if (!mutResolverSet.has(name)) {
+        mismatches.push(`Mutation "` + name + `": SDL field but no resolver`);
+        return;
+      }
+    });
+    let queryResolverSet = new Set(queryResolverNames);
+    queryFieldNames.forEach(name => {
+      if (!queryResolverSet.has(name)) {
+        mismatches.push(`Query "` + name + `": SDL field but no resolver`);
+        return;
+      }
+    });
+    let mutFieldSet = new Set(mutFieldNames);
+    mutResolverNames.forEach(name => {
+      if (!mutFieldSet.has(name)) {
+        mismatches.push(`Mutation "` + name + `": resolver but no SDL field`);
+        return;
+      }
+    });
+    let queryFieldSet = new Set(queryFieldNames);
+    queryResolverNames.forEach(name => {
+      if (!queryFieldSet.has(name)) {
+        mismatches.push(`Query "` + name + `": resolver but no SDL field`);
+        return;
+      }
+    });
+    let typeNames = typeDefinitions.contents.map(GraphQL_Stitcher$ReventlessCore.extractLeadingName);
+    return {
+      registeredTypeDefinitions: typeNames,
+      registeredMutationFields: mutFieldNames,
+      registeredQueryFields: queryFieldNames,
+      registeredMutationResolvers: mutResolverNames,
+      registeredQueryResolvers: queryResolverNames,
+      typeCount: typeNames.length,
+      sdlMutationCount: mutFieldNames.length,
+      sdlQueryCount: queryFieldNames.length,
+      resolverMutationCount: mutResolverNames.length,
+      resolverQueryCount: queryResolverNames.length,
+      mismatches: mismatches,
+      fullSdl: lastFullSdl.contents,
+      serverRunning: Stdlib_Option.isSome(activeServer.contents)
+    };
+  };
+  let printDiagnostics = () => {
+    let p = s => log.info(label, undefined, s);
+    let d = diagnostics();
+    p("Diagnostics");
+    p(`  Types: ` + d.typeCount.toString());
+    p(`  Mutations: ` + d.sdlMutationCount.toString() + ` SDL fields, ` + d.resolverMutationCount.toString() + ` resolvers`);
+    p(`  Queries: ` + d.sdlQueryCount.toString() + ` SDL fields, ` + d.resolverQueryCount.toString() + ` resolvers`);
+    if (d.mismatches.length !== 0) {
+      p(`  Mismatches (` + d.mismatches.length.toString() + `):`);
+      d.mismatches.forEach(m => p(`    - ` + m));
+    } else {
+      p("  No mismatches");
+    }
+    p(`  Server running: ` + (
+      d.serverRunning ? "yes" : "no"
+    ));
+    let sdl = d.fullSdl;
+    if (sdl !== undefined) {
+      p("");
+      p("--- Full SDL ---");
+      sdl.split("\n").forEach(p);
+      return p("--- End ---");
+    } else {
+      return p("  No SDL recorded");
+    }
+  };
+  return {
+    registerMutations: registerMutations,
+    registerQueries: registerQueries,
+    registerSubscriptions: registerSubscriptions,
+    registerTypes: registerTypes,
+    getMutationResolver: getMutationResolver,
+    getQueryResolver: getQueryResolver,
+    start: start,
+    stop: stop,
+    reset: reset,
+    buildSdl: buildSdl,
+    getFullSdl: getFullSdl,
+    getSchema: getSchema,
+    diagnostics: diagnostics,
+    printDiagnostics: printDiagnostics
+  };
+}
+
+let YG;
+
+export {
+  YG,
+  log,
+  debug,
+  extractFieldName,
+  make,
+}
+/* log Not a pure module */

package/src/adapter/Heartbeat/LocalHeartbeatRunner.res

@@ -0,0 +1,57 @@
+// In-memory HeartbeatRunner — satisfies Heartbeat_Adapter.Runner.
+//
+// Instead of creating a CloudWatch Event Rule (as in AWS), sets up a setInterval
+// that fires the heartbeat handler directly at the configured timeout interval.
+//
+// Awaits the handler Deferred on each tick — no None check, no warning log.
+// After the first tick the Deferred is already completed, so subsequent await_
+// calls return immediately.
+//
+// Usage: pass LocalHeartbeatRunner to Plugin_Builder.Make as the HeartbeatRunner
+// parameter when building a plugin in test/local mode.
+//
+// Call reset() in afterAll/afterEach to clear active timers between test suites.
+
+type runtimeParts = LocalRuntimeEnvironment.parts
+
+type timerHandle
+
+@val
+external setIntervalJs: (unit => unit, int) => timerHandle = "setInterval"
+@val
+external clearIntervalJs: timerHandle => unit = "clearInterval"
+
+let activeTimers: ref<dict<timerHandle>> = ref(Dict.make())
+
+let make: ReventlessCore.Heartbeat_Adapter.runnerMaker<runtimeParts> = (
+  ~name,
+  ~remoteChannel as _,
+  ~timeout,
+  ~runtime,
+  ~opts as _,
+) => {
+  let handlerDeferred = runtime.parts.handlerDeferred
+  let intervalMs = timeout * 60 * 1000
+  let handle = setIntervalJs(
+    () => {
+      // Await the handler Deferred on each tick. Since the Deferred is completed
+      // during make() setup, this resolves immediately after the first tick.
+      handlerDeferred
+      ->Deferred.await_
+      ->Effect.flatMap(handler =>
+        Effect.promise(() => handler(Obj.magic(()), ()))
+      )
+      ->Effect.runPromise
+      ->ignore
+    },
+    intervalMs,
+  )
+  activeTimers.contents->Dict.set(name, handle)
+  {resources: []}
+}
+
+// Clear all active heartbeat timers. Call in afterAll for test isolation.
+let reset = () => {
+  activeTimers.contents->Dict.valuesToArray->Array.forEach(clearIntervalJs)
+  activeTimers.contents = Dict.make()
+}

package/src/adapter/Heartbeat/LocalHeartbeatRunner.res.mjs

@@ -0,0 +1,34 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+
+let activeTimers = {
+  contents: {}
+};
+
+function make(name, param, timeout, runtime, param$1) {
+  let handlerDeferred = runtime.parts.handlerDeferred;
+  let intervalMs = (timeout * 60 | 0) * 1000 | 0;
+  let handle = setInterval(() => {
+    Effect.runPromise(Effect.flatMap(Deferred.await(handlerDeferred), handler => Effect.promise(() => handler(undefined, undefined))));
+  }, intervalMs);
+  activeTimers.contents[name] = handle;
+  return {
+    resources: []
+  };
+}
+
+function reset() {
+  Object.values(activeTimers.contents).forEach(prim => {
+    clearInterval(prim);
+  });
+  activeTimers.contents = {};
+}
+
+export {
+  activeTimers,
+  make,
+  reset,
+}
+/* effect/Effect Not a pure module */