@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/EventLog/EventLogStorage_InMemory.res.mjs

@@ -0,0 +1,117 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as STM from "effect/STM";
+import * as TRef from "effect/TRef";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as EventLogStorage_Sqlite$ReventlessLocal from "./EventLogStorage_Sqlite.res.mjs";
+
+function makeMemoryStorage(_name, param) {
+  let eventsRef = Effect.runSync(STM.commit(TRef.make({})));
+  let append = (seqNr, id, jsons) => Effect.runPromise(STM.commit(TRef.modify(eventsRef, events => {
+    let existing = Stdlib_Option.getOr(events[id], []);
+    let currentCount = existing.length;
+    if (seqNr !== currentCount) {
+      return [
+        {
+          TAG: "Error",
+          _0: "conflict"
+        },
+        events
+      ];
+    } else {
+      events[id] = existing.concat(jsons);
+      return [
+        {
+          TAG: "Ok",
+          _0: undefined
+        },
+        events
+      ];
+    }
+  })));
+  let replayStream = id => Stream$1.flatMap(Stream$1.fromEffect(Effect.map(STM.commit(TRef.get(eventsRef)), events => Stdlib_Option.getOr(events[id], []))), arr => Stream$1.fromIterable(arr));
+  let replay = id => Effect.runPromise(Stream.runCollect(replayStream(id)));
+  let appendStream = (startingSeqNr, id, stream) => {
+    let seqNrRef = {
+      contents: startingSeqNr
+    };
+    return Stream$1.runForEach(stream, json => Effect.flatMap(STM.commit(TRef.modify(eventsRef, events => {
+      let existing = Stdlib_Option.getOr(events[id], []);
+      let currentCount = existing.length;
+      if (seqNrRef.contents !== currentCount) {
+        return [
+          {
+            TAG: "Error",
+            _0: "conflict"
+          },
+          events
+        ];
+      } else {
+        events[id] = existing.concat([json]);
+        return [
+          {
+            TAG: "Ok",
+            _0: undefined
+          },
+          events
+        ];
+      }
+    })), result => {
+      if (result.TAG !== "Ok") {
+        return Effect.fail(result._0);
+      }
+      seqNrRef.contents = seqNrRef.contents + 1 | 0;
+      return Effect.succeed();
+    }));
+  };
+  return [
+    _name,
+    replay,
+    {
+      resources: [],
+      operations: Pulumi.output({
+        append: append,
+        replay: replay,
+        replayStream: replayStream,
+        appendStream: appendStream
+      })
+    }
+  ];
+}
+
+function make(name, opts) {
+  return makeMemoryStorage(name, opts)[2];
+}
+
+function Make(Bus) {
+  let make = (name, opts) => {
+    let db = BackendState$ReventlessLocal.getDb();
+    if (db !== undefined) {
+      let match = EventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), name, opts);
+      Bus.registerEventLogReplay(match[0], match[1]);
+      return match[2];
+    }
+    let match$1 = makeMemoryStorage(name, opts);
+    Bus.registerEventLogReplay(match$1[0], match$1[1]);
+    return match$1[2];
+  };
+  return {
+    make: make
+  };
+}
+
+let makeStorage = makeMemoryStorage;
+
+export {
+  makeMemoryStorage,
+  makeStorage,
+  make,
+  Make,
+}
+/* Stream Not a pure module */

package/src/adapter/EventLog/EventLogStorage_Sqlite.res

@@ -0,0 +1,145 @@
+// SQLite-backed event log storage.
+//
+// Schema (shared across all EventLogs — partitioned by log_name):
+//   CREATE TABLE event_log (
+//     log_name TEXT NOT NULL,
+//     aggregate_id TEXT NOT NULL,
+//     seq_nr INTEGER NOT NULL,
+//     payload TEXT NOT NULL,  -- JSON.stringify of one event
+//     PRIMARY KEY (log_name, aggregate_id, seq_nr)
+//   )
+//
+// Optimistic concurrency: the append caller passes the seqNr that
+// corresponds to "no events appended yet after my seqNr". If another caller
+// raced and inserted at the same (log_name, aggregate_id, seq_nr), the PK
+// conflict becomes `Error("conflict")`.
+
+open ReventlessCore
+
+let ensureSchema = (db: SqliteDriver.t) =>
+  db->SqliteDriver.exec(
+    "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))",
+  )
+
+// Decodes the JSON column to a JSON.t. Returns JSON.Null on unparseable input
+// (should not happen for data we wrote ourselves).
+let decodePayload = (row: dict<JSON.t>): JSON.t =>
+  switch row->Dict.get("payload") {
+  | Some(JSON.String(s)) =>
+    switch JSON.parseOrThrow(s) {
+    | json => json
+    | exception _ => JSON.Encode.null
+    }
+  | _ => JSON.Encode.null
+  }
+
+// Total events persisted across all aggregates in this table. Used at startup to
+// seed the event-tap counter so the timeline numbering continues across restarts.
+let countAll = (db: SqliteDriver.t): int => {
+  ensureSchema(db)
+  switch db->SqliteDriver.prepare("SELECT COUNT(*) AS c FROM event_log")->SqliteDriver.get([]) {
+  | Some(row) =>
+    switch row->Dict.get("c") {
+    | Some(JSON.Number(n)) => Float.toInt(n)
+    | _ => 0
+    }
+  | None => 0
+  }
+}
+
+let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
+  ensureSchema(db)
+
+  let insertStmt = db->SqliteDriver.prepare(
+    "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)",
+  )
+  let countStmt = db->SqliteDriver.prepare(
+    "SELECT COUNT(*) AS c FROM event_log WHERE log_name=? AND aggregate_id=?",
+  )
+  let selectByIdStmt = db->SqliteDriver.prepare(
+    "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? ORDER BY seq_nr ASC",
+  )
+
+  let currentCount = (id: string): int =>
+    switch countStmt->SqliteDriver.get([JSON.Encode.string(name), JSON.Encode.string(id)]) {
+    | Some(row) =>
+      switch row->Dict.get("c") {
+      | Some(JSON.Number(n)) => Float.toInt(n)
+      | _ => 0
+      }
+    | None => 0
+    }
+
+  let append: EventLog.append<string, JSON.t> = async (seqNr, id, jsons) => {
+    try {
+      db->SqliteDriver.transaction(() => {
+        let existing = currentCount(id)
+        if seqNr != existing {
+          throw(Failure("conflict"))
+        }
+        jsons->Array.forEachWithIndex((json, i) => {
+          insertStmt->SqliteDriver.run([
+            JSON.Encode.string(name),
+            JSON.Encode.string(id),
+            JSON.Encode.int(seqNr + i),
+            JSON.Encode.string(JSON.stringify(json)),
+          ])
+        })
+      })
+      Ok()
+    } catch {
+    | Failure(msg) => Error(msg)
+    | _ => Error("conflict")
+    }
+  }
+
+  let replayArray = (id: string): array<JSON.t> =>
+    selectByIdStmt
+    ->SqliteDriver.all([JSON.Encode.string(name), JSON.Encode.string(id)])
+    ->Array.map(decodePayload)
+
+  let replay: EventLog.replay<string, JSON.t> = async id => replayArray(id)
+
+  // node:sqlite's iterate() could back a lazy stream, but the current Stream
+  // API only has array-based fromIterable. Small events, dev-only backend →
+  // materialise via all() and wrap. Swap to a lazy adapter if it matters.
+  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
+    replayArray(id)->Stream.fromIterable
+
+  let appendStream: EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) => {
+    let seqNrRef = ref(startingSeqNr)
+    stream->Stream.runForEach(json => {
+      let currentSeq = seqNrRef.contents
+      Effect.promise(() => append(currentSeq, id, [json]))->Effect.flatMap(result =>
+        switch result {
+        | Ok() =>
+          seqNrRef := currentSeq + 1
+          Effect.succeed()
+        | Error(msg) => Effect.fail(msg)
+        }
+      )
+    })
+  }
+
+  (
+    name,
+    replay,
+    {
+      EventLog_Adapter.resources: [],
+      operations: Pulumi.Output.make({
+        EventLog_Adapter.append,
+        replay,
+        replayStream,
+        appendStream,
+      }),
+    },
+  )
+}
+
+module Make = (Bus: LocalBus.T, DbProvider: {let db: SqliteDriver.t}) => {
+  let make: EventLog_Adapter.storageMaker = (~name, ~opts) => {
+    let (storageName, replay, storage) = makeStorage(~db=DbProvider.db, ~name, ~opts)
+    Bus.registerEventLogReplay(storageName, replay)
+    storage
+  }
+}

package/src/adapter/EventLog/EventLogStorage_Sqlite.res.mjs

@@ -0,0 +1,155 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+
+function ensureSchema(db) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+}
+
+function decodePayload(row) {
+  let match = row["payload"];
+  if (match === undefined) {
+    return null;
+  }
+  if (typeof match !== "string") {
+    return null;
+  }
+  try {
+    return JSON.parse(match);
+  } catch (exn) {
+    return null;
+  }
+}
+
+function countAll(db) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log"), []);
+  if (row === undefined) {
+    return 0;
+  }
+  let match = row["c"];
+  if (typeof match === "number") {
+    return match | 0;
+  } else {
+    return 0;
+  }
+}
+
+function makeStorage(db, name, param) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  let insertStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)");
+  let countStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log WHERE log_name=? AND aggregate_id=?");
+  let selectByIdStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? ORDER BY seq_nr ASC");
+  let currentCount = id => {
+    let row = SqliteDriver$ReventlessLocal.get(countStmt, [
+      name,
+      id
+    ]);
+    if (row === undefined) {
+      return 0;
+    }
+    let match = row["c"];
+    if (typeof match === "number") {
+      return match | 0;
+    } else {
+      return 0;
+    }
+  };
+  let append = async (seqNr, id, jsons) => {
+    try {
+      SqliteDriver$ReventlessLocal.transaction(db, () => {
+        let existing = currentCount(id);
+        if (seqNr !== existing) {
+          throw {
+            RE_EXN_ID: "Failure",
+            _1: "conflict",
+            Error: new Error()
+          };
+        }
+        jsons.forEach((json, i) => SqliteDriver$ReventlessLocal.run(insertStmt, [
+          name,
+          id,
+          seqNr + i | 0,
+          JSON.stringify(json)
+        ]));
+      });
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    } catch (raw_msg) {
+      let msg = Primitive_exceptions.internalToException(raw_msg);
+      if (msg.RE_EXN_ID === "Failure") {
+        return {
+          TAG: "Error",
+          _0: msg._1
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "conflict"
+        };
+      }
+    }
+  };
+  let replayArray = id => SqliteDriver$ReventlessLocal.all(selectByIdStmt, [
+    name,
+    id
+  ]).map(decodePayload);
+  let replay = replayArray;
+  let replayStream = id => Stream.fromIterable(replayArray(id));
+  let appendStream = (startingSeqNr, id, stream) => {
+    let seqNrRef = {
+      contents: startingSeqNr
+    };
+    return Stream.runForEach(stream, json => {
+      let currentSeq = seqNrRef.contents;
+      return Effect.flatMap(Effect.promise(() => append(currentSeq, id, [json])), result => {
+        if (result.TAG !== "Ok") {
+          return Effect.fail(result._0);
+        }
+        seqNrRef.contents = currentSeq + 1 | 0;
+        return Effect.succeed();
+      });
+    });
+  };
+  return [
+    name,
+    replay,
+    {
+      resources: [],
+      operations: Pulumi.output({
+        append: append,
+        replay: replay,
+        replayStream: replayStream,
+        appendStream: appendStream
+      })
+    }
+  ];
+}
+
+function Make(Bus) {
+  return DbProvider => {
+    let make = (name, opts) => {
+      let match = makeStorage(DbProvider.db, name, opts);
+      Bus.registerEventLogReplay(match[0], match[1]);
+      return match[2];
+    };
+    return {
+      make: make
+    };
+  };
+}
+
+export {
+  ensureSchema,
+  decodePayload,
+  countAll,
+  makeStorage,
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/EventTopic/LocalEventTopicPublisher.res

@@ -0,0 +1,36 @@
+// In-memory EventTopic publisher.
+// The resource name doubles as the bus topic key that EventCollectorChannel subscribes to.
+
+module Make = (Bus: LocalBus.T) => {
+  let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageResources as _, ~opts as _) => {
+    let publishJson = (service, meta, json) => Bus.publishEvent(name, service, meta, json)
+    let publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream = stream =>
+      stream
+      ->Stream.grouped(10)
+      ->Stream.runForEach(items =>
+        Effect.promise(() =>
+          items
+          ->Array.map(({ReventlessInfra.EventTopic.service, meta, json}) =>
+            publishJson(service, meta, json)
+          )
+          ->Promise.all
+          ->Promise.thenResolve(_ => ())
+        )
+      )
+
+    {
+      resources: [
+        ReventlessInfra.Adapter.make(
+          ~name=name->Pulumi.Output.make,
+          ~id=name->Pulumi.Output.make,
+          ~urn=name->Pulumi.Output.make,
+          ~service="memory:InMemory"->Pulumi.Output.make,
+        ),
+      ],
+      publishJson: (
+        (service, meta, json) => Bus.publishEvent(name, service, meta, json)
+      )->Pulumi.Output.make,
+      publishJsonStream: publishJsonStream->Pulumi.Output.make,
+    }
+  }
+}

package/src/adapter/EventTopic/LocalEventTopicPublisher.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+
+function Make(Bus) {
+  let make = (name, param, param$1) => {
+    let publishJsonStream = stream => Stream$1.runForEach(Stream.grouped(stream, 10), items => Effect.promise(() => Promise.all(items.map(param => {
+      let service = param.service;
+      let meta = param.meta;
+      let json = param.json;
+      return Bus.publishEvent(name, service, meta, json);
+    })).then(param => {})));
+    return {
+      resources: [Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined)],
+      publishJson: Pulumi.output((service, meta, json) => Bus.publishEvent(name, service, meta, json)),
+      publishJsonStream: Pulumi.output(publishJsonStream)
+    };
+  };
+  return {
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/adapter/GraphQL_Server.res

@@ -0,0 +1,6 @@
+// Backwards-compatibility re-export of DomainGraphQL_Server.
+// The domain singleton was extracted to DomainGraphQL_Server.res as part of
+// the Phase 6 symmetric server refactor. This file re-exports everything so
+// existing imports (tests, adapters referencing GraphQL_Server.*) continue to
+// compile without changes. New code should import DomainGraphQL_Server directly.
+include DomainGraphQL_Server

package/src/adapter/GraphQL_Server.res.mjs

@@ -0,0 +1,154 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DomainGraphQL_Server$ReventlessLocal from "./DomainGraphQL_Server.res.mjs";
+
+let YG = DomainGraphQL_Server$ReventlessLocal.YG;
+
+let log = DomainGraphQL_Server$ReventlessLocal.log;
+
+let readBody = DomainGraphQL_Server$ReventlessLocal.readBody;
+
+let _writeJson = DomainGraphQL_Server$ReventlessLocal._writeJson;
+
+let _loginRejected = DomainGraphQL_Server$ReventlessLocal._loginRejected;
+
+let handleLogin = DomainGraphQL_Server$ReventlessLocal.handleLogin;
+
+let handleLogout = DomainGraphQL_Server$ReventlessLocal.handleLogout;
+
+let _isInvalidBearer = DomainGraphQL_Server$ReventlessLocal._isInvalidBearer;
+
+let _dispatch = DomainGraphQL_Server$ReventlessLocal._dispatch;
+
+let buildAuthContext = DomainGraphQL_Server$ReventlessLocal.buildAuthContext;
+
+let encodeGlobalId = DomainGraphQL_Server$ReventlessLocal.encodeGlobalId;
+
+let decodeGlobalId = DomainGraphQL_Server$ReventlessLocal.decodeGlobalId;
+
+let mutationResolvers = DomainGraphQL_Server$ReventlessLocal.mutationResolvers;
+
+let queryResolvers = DomainGraphQL_Server$ReventlessLocal.queryResolvers;
+
+let subscriptionResolvers = DomainGraphQL_Server$ReventlessLocal.subscriptionResolvers;
+
+let mutationFields = DomainGraphQL_Server$ReventlessLocal.mutationFields;
+
+let queryFields = DomainGraphQL_Server$ReventlessLocal.queryFields;
+
+let subscriptionFields = DomainGraphQL_Server$ReventlessLocal.subscriptionFields;
+
+let typeDefinitions = DomainGraphQL_Server$ReventlessLocal.typeDefinitions;
+
+let registerMutations = DomainGraphQL_Server$ReventlessLocal.registerMutations;
+
+let registerQueries = DomainGraphQL_Server$ReventlessLocal.registerQueries;
+
+let registerSubscriptions = DomainGraphQL_Server$ReventlessLocal.registerSubscriptions;
+
+let getMutationResolver = DomainGraphQL_Server$ReventlessLocal.getMutationResolver;
+
+let getQueryResolver = DomainGraphQL_Server$ReventlessLocal.getQueryResolver;
+
+let registerTypes = DomainGraphQL_Server$ReventlessLocal.registerTypes;
+
+let nodeTypeRegistry = DomainGraphQL_Server$ReventlessLocal.nodeTypeRegistry;
+
+let registerNodeType = DomainGraphQL_Server$ReventlessLocal.registerNodeType;
+
+let nodeResolverCallback = DomainGraphQL_Server$ReventlessLocal.nodeResolverCallback;
+
+let registerNodeResolverCallback = DomainGraphQL_Server$ReventlessLocal.registerNodeResolverCallback;
+
+let buildNodeResolver = DomainGraphQL_Server$ReventlessLocal.buildNodeResolver;
+
+let debug = DomainGraphQL_Server$ReventlessLocal.debug;
+
+let activeServer = DomainGraphQL_Server$ReventlessLocal.activeServer;
+
+let activeSchema = DomainGraphQL_Server$ReventlessLocal.activeSchema;
+
+let lastFullSdl = DomainGraphQL_Server$ReventlessLocal.lastFullSdl;
+
+let buildSdl = DomainGraphQL_Server$ReventlessLocal.buildSdl;
+
+let start = DomainGraphQL_Server$ReventlessLocal.start;
+
+let stop = DomainGraphQL_Server$ReventlessLocal.stop;
+
+let rebuildSchema = DomainGraphQL_Server$ReventlessLocal.rebuildSchema;
+
+let reset = DomainGraphQL_Server$ReventlessLocal.reset;
+
+let getRegisteredSdl = DomainGraphQL_Server$ReventlessLocal.getRegisteredSdl;
+
+let getRegisteredResolverNames = DomainGraphQL_Server$ReventlessLocal.getRegisteredResolverNames;
+
+let getFullSdl = DomainGraphQL_Server$ReventlessLocal.getFullSdl;
+
+let getSchema = DomainGraphQL_Server$ReventlessLocal.getSchema;
+
+let getLiveSdl = DomainGraphQL_Server$ReventlessLocal.getLiveSdl;
+
+let printLiveSdl = DomainGraphQL_Server$ReventlessLocal.printLiveSdl;
+
+let extractFieldName = DomainGraphQL_Server$ReventlessLocal.extractFieldName;
+
+let diagnostics = DomainGraphQL_Server$ReventlessLocal.diagnostics;
+
+let printDiagnostics = DomainGraphQL_Server$ReventlessLocal.printDiagnostics;
+
+let asInterface = DomainGraphQL_Server$ReventlessLocal.asInterface;
+
+export {
+  YG,
+  log,
+  readBody,
+  _writeJson,
+  _loginRejected,
+  handleLogin,
+  handleLogout,
+  _isInvalidBearer,
+  _dispatch,
+  buildAuthContext,
+  encodeGlobalId,
+  decodeGlobalId,
+  mutationResolvers,
+  queryResolvers,
+  subscriptionResolvers,
+  mutationFields,
+  queryFields,
+  subscriptionFields,
+  typeDefinitions,
+  registerMutations,
+  registerQueries,
+  registerSubscriptions,
+  getMutationResolver,
+  getQueryResolver,
+  registerTypes,
+  nodeTypeRegistry,
+  registerNodeType,
+  nodeResolverCallback,
+  registerNodeResolverCallback,
+  buildNodeResolver,
+  debug,
+  activeServer,
+  activeSchema,
+  lastFullSdl,
+  buildSdl,
+  start,
+  stop,
+  rebuildSchema,
+  reset,
+  getRegisteredSdl,
+  getRegisteredResolverNames,
+  getFullSdl,
+  getSchema,
+  getLiveSdl,
+  printLiveSdl,
+  extractFieldName,
+  diagnostics,
+  printDiagnostics,
+  asInterface,
+}
+/* DomainGraphQL_Server-ReventlessLocal Not a pure module */