@reventlessdev/reventless-local 3.0.0-alpha.138 → 3.0.0-alpha.140

package/tests/adapter/GraphQLSubscriptionBridgeTest.res

@@ -0,0 +1,120 @@
+// Focused seam test for the promoted, transport-neutral GraphQL server runtime
+// (`ReventlessGraphqlServer.GraphQL_ServerInstance` + `GraphQL_SubscriptionBridge`).
+//
+// The promotion introduced ONE behavioral seam: the subscription bridge takes
+// its PubSub instance as a *parameter* instead of constructing a module
+// singleton. This test drives the promoted modules directly with an
+// **explicitly injected** in-process PubSub (never the local singleton) to
+// prove the parameterized-PubSub seam is behavior-preserving:
+//
+//   1. registerAll builds the subscription SDL on a fresh GraphQL_ServerInstance,
+//      strips @aws_subscribe, and injects `scalar AWSJSON`.
+//   2. A resolver from makeFieldResolver, subscribed on the injected PubSub,
+//      receives a payload published via Bridge.publish on that same PubSub.
+
+@@warning("-44")
+
+open JestGlobals
+
+module Bridge = ReventlessGraphqlServer.GraphQL_SubscriptionBridge
+module Server = ReventlessGraphqlServer.GraphQL_ServerInstance
+
+// AsyncIterable.next() binding — yoga's PubSub returns {value, done}.
+type asyncIterResult = {value: JSON.t, done: bool}
+@send external iterNext: 'a => promise<asyncIterResult> = "next"
+
+@val external setTimeout: (unit => unit, int) => int = "setTimeout"
+
+// The subscription resolver object shape produced by makeFieldResolver.
+// `subscribe` returns yoga's Repeater-based AsyncIterable (kept opaque).
+type iterable
+type subResolver = {
+  subscribe: (JSON.t, JSON.t, JSON.t) => iterable,
+  resolve: JSON.t => JSON.t,
+}
+
+let startConsumer = (iter: 'iter, timeoutMs: int): promise<Null.t<JSON.t>> => {
+  let timeoutP = Promise.make((resolve, _) => {
+    let _: int = setTimeout(() => resolve(Null.null), timeoutMs)
+  })
+  let consumeP = async () =>
+    try {
+      let result = await iter->iterNext
+      result.done ? Null.null : result.value->Null.make
+    } catch {
+    | _ => Null.null
+    }
+  Promise.race([timeoutP, consumeP()])
+}
+
+let yieldTick = (): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _: int = setTimeout(() => resolve(), 10)
+  })
+
+describe("GraphQL_SubscriptionBridge — injected PubSub seam", () => {
+  testSync("registerAll builds subscription SDL, strips @aws_subscribe, injects AWSJSON", () => {
+    let pubSub = GraphqlYoga.createPubSub()
+    let server = Server.make(~label="SeamTest")
+
+    let sdlField =
+      "onCatalogProduct_stateChanged: CatalogProduct\n    @aws_subscribe(mutations: [\"addProduct\"])"
+
+    Bridge.registerAll(
+      ~server,
+      ~sdlFields=[sdlField],
+      ~sourceAEntries=[],
+      ~sourceBEntries=[{fieldName: "onCatalogProduct_stateChanged", topic: "onCatalogProduct_stateChanged"}],
+      ~pubSub,
+    )
+
+    let sdl = server.buildSdl()
+    expect(sdl->String.includes("type Subscription"))->toBe(true)
+    expect(sdl->String.includes("onCatalogProduct_stateChanged"))->toBe(true)
+    // @aws_subscribe is AppSync-only and must be stripped for yoga.
+    expect(sdl->String.includes("@aws_subscribe"))->toBe(false)
+    // AWSJSON scalar injected so yoga accepts AppSync-derived event log types.
+    expect(sdl->String.includes("scalar AWSJSON"))->toBe(true)
+  })
+
+  testPromise("makeFieldResolver + publish deliver over the injected PubSub", async () => {
+    let pubSub = GraphqlYoga.createPubSub()
+    let topic = "onCatalogProduct_stateChanged"
+
+    let resolver: subResolver = Obj.magic(Bridge.makeFieldResolver(~pubSub, topic))
+    let iter = resolver.subscribe(JSON.Encode.null, JSON.Encode.null, JSON.Encode.null)
+    let consumerPromise = startConsumer(iter, 1000)
+    await yieldTick()
+
+    let payload =
+      JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("prod-1"))]))
+    Bridge.publish(~pubSub, topic, payload)
+
+    let received = await consumerPromise
+    switch received->Null.toOption {
+    | Some(msg) => expect(msg)->toEqual(payload)
+    | None => expect("injected-pubsub: timed out")->toBe("received")
+    }
+  })
+
+  testPromise("a separate injected PubSub does NOT receive another's publish", async () => {
+    // Proves isolation: publishing on PubSub A never reaches a subscriber on B.
+    let pubSubA = GraphqlYoga.createPubSub()
+    let pubSubB = GraphqlYoga.createPubSub()
+    let topic = "onCatalogProduct_stateChanged"
+
+    let resolverB: subResolver = Obj.magic(Bridge.makeFieldResolver(~pubSub=pubSubB, topic))
+    let iterB = resolverB.subscribe(JSON.Encode.null, JSON.Encode.null, JSON.Encode.null)
+    let consumerPromise = startConsumer(iterB, 300)
+    await yieldTick()
+
+    Bridge.publish(
+      ~pubSub=pubSubA,
+      topic,
+      JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("prod-1"))])),
+    )
+
+    let received = await consumerPromise
+    expect(received->Null.toOption)->toEqual(None)
+  })
+})

package/tests/adapter/GraphQLSubscriptionBridgeTest.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as GraphqlYoga from "graphql-yoga";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as GraphQL_ServerInstance$ReventlessGraphqlServer from "@reventlessdev/reventless-graphql-server/src/GraphQL_ServerInstance.res.mjs";
+import * as GraphQL_SubscriptionBridge$ReventlessGraphqlServer from "@reventlessdev/reventless-graphql-server/src/GraphQL_SubscriptionBridge.res.mjs";
+
+function startConsumer(iter, timeoutMs) {
+  let timeoutP = new Promise((resolve, param) => {
+    setTimeout(() => resolve(null), timeoutMs);
+  });
+  let consumeP = async () => {
+    try {
+      let result = await iter.next();
+      if (result.done) {
+        return null;
+      } else {
+        return result.value;
+      }
+    } catch (exn) {
+      return null;
+    }
+  };
+  return Promise.race([
+    timeoutP,
+    consumeP()
+  ]);
+}
+
+function yieldTick() {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 10);
+  });
+}
+
+globalThis.describe("GraphQL_SubscriptionBridge — injected PubSub seam", () => {
+  globalThis.test("registerAll builds subscription SDL, strips @aws_subscribe, injects AWSJSON", () => {
+    let pubSub = GraphqlYoga.createPubSub();
+    let server = GraphQL_ServerInstance$ReventlessGraphqlServer.make("SeamTest");
+    GraphQL_SubscriptionBridge$ReventlessGraphqlServer.registerAll(server, ["onCatalogProduct_stateChanged: CatalogProduct\n    @aws_subscribe(mutations: [\"addProduct\"])"], [], [{
+        fieldName: "onCatalogProduct_stateChanged",
+        topic: "onCatalogProduct_stateChanged"
+      }], pubSub);
+    let sdl = server.buildSdl();
+    globalThis.expect(sdl.includes("type Subscription")).toBe(true);
+    globalThis.expect(sdl.includes("onCatalogProduct_stateChanged")).toBe(true);
+    globalThis.expect(sdl.includes("@aws_subscribe")).toBe(false);
+    globalThis.expect(sdl.includes("scalar AWSJSON")).toBe(true);
+  });
+  globalThis.test("makeFieldResolver + publish deliver over the injected PubSub", async () => {
+    let pubSub = GraphqlYoga.createPubSub();
+    let topic = "onCatalogProduct_stateChanged";
+    let resolver = GraphQL_SubscriptionBridge$ReventlessGraphqlServer.makeFieldResolver(pubSub, topic);
+    let iter = resolver.subscribe(null, null, null);
+    let consumerPromise = startConsumer(iter, 1000);
+    await yieldTick();
+    let payload = Object.fromEntries([[
+        "id",
+        "prod-1"
+      ]]);
+    GraphQL_SubscriptionBridge$ReventlessGraphqlServer.publish(pubSub, topic, payload);
+    let received = await consumerPromise;
+    if (received !== null) {
+      globalThis.expect(received).toEqual(payload);
+    } else {
+      globalThis.expect("injected-pubsub: timed out").toBe("received");
+    }
+  });
+  globalThis.test("a separate injected PubSub does NOT receive another's publish", async () => {
+    let pubSubA = GraphqlYoga.createPubSub();
+    let pubSubB = GraphqlYoga.createPubSub();
+    let topic = "onCatalogProduct_stateChanged";
+    let resolverB = GraphQL_SubscriptionBridge$ReventlessGraphqlServer.makeFieldResolver(pubSubB, topic);
+    let iterB = resolverB.subscribe(null, null, null);
+    let consumerPromise = startConsumer(iterB, 300);
+    await yieldTick();
+    GraphQL_SubscriptionBridge$ReventlessGraphqlServer.publish(pubSubA, topic, Object.fromEntries([[
+        "id",
+        "prod-1"
+      ]]));
+    let received = await consumerPromise;
+    globalThis.expect(received === null ? undefined : Primitive_option.some(received)).toEqual(undefined);
+  });
+});
+
+let Bridge;
+
+let Server;
+
+export {
+  Bridge,
+  Server,
+  startConsumer,
+  yieldTick,
+}
+/*  Not a pure module */

package/src/adapter/GraphQL_ServerInstance.res

@@ -1,310 +0,0 @@
-// 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,
-  }
-}