@powerhousedao/switchboard 6.2.3-dev.49 → 6.2.3-dev.50

package/dist/server.d.mts

@@ -1,14 +1,21 @@
 import { ILogger } from "document-model";
-import { ChannelScheme, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ModelManifestEntry, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
+import "@powerhousedao/reactor-api/pglite-node";
+import { ChannelScheme, Database, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ModelManifestEntry, PoolInstrumentation, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
 import { AttachmentReferenceProjectionCapability } from "@powerhousedao/reactor-api";
 import { IAttachmentService } from "@powerhousedao/reactor-attachments";
 import { IRenown } from "@renown/sdk/node";
+import { Kysely } from "kysely";
 import { IErasureService } from "@powerhousedao/reactor-privacy";
 import { DriveInput } from "@powerhousedao/shared/document-drive";
 import { DocumentModelModule, ISigner, SignaturePolicy, UpgradeManifest } from "@powerhousedao/shared/document-model";
+import "@electric-sql/pglite";
 import "@powerhousedao/reactor-workflow";
 import "@powerhousedao/shared/processors";
 import { IRenown as IRenown$1 } from "@renown/sdk";
+//#region src/pglite-version.d.ts
+declare const SUPPORTED_PG_MAJORS: readonly [16, 17];
+type SupportedPgMajor = (typeof SUPPORTED_PG_MAJORS)[number];
+//#endregion
 //#region src/privacy.d.mts
 type PrivacyOptions = {
   /** Wins over PH_PRIVACY_ENABLED. */
@@ -246,7 +253,8 @@ type SwitchboardReactorDefaultsOptions = {
   /**
    * Channel scheme. Defaults to `ChannelScheme.SWITCHBOARD`, which populates
    * `reactorModule.syncModule.syncManager` — required by reactor-api. Set
-   * to `false` only if the caller will configure a scheme themselves.
+   * to `false` if the caller configures sync itself (`withChannelScheme` or
+   * `withSync`); the builder refuses both together.
    */
   channelScheme?: ChannelScheme | false;
   /** Defaults to true. Set false when the caller owns SIGINT handling. */
@@ -296,6 +304,29 @@ export declare class StoredDocumentsRefusedError extends Error {
  * surfaced so we don't silently mask real issues (permissions, bad host, …).
  */
 export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * The reactor's storage handle, plus the pool instrumentation when that
+ * storage is Postgres. The PGlite branch has no `pg.Pool` at all, so the
+ * instrumentation is absent rather than optional-by-convention.
+ */
+type ReactorStorage = {
+  kysely: Kysely<Database>;
+  poolInstrumentation: PoolInstrumentation | undefined;
+};
+export declare function createReactorKysely(opts: {
+  reactorDbUrl: string | undefined;
+  reactorPgliteDir: string | null;
+  reactorPgliteMajor: SupportedPgMajor | null;
+  inMemory: boolean;
+  /**
+   * Resolved lazily: only the Postgres branch has a host pool, and
+   * {@link resolveHostPoolSize} throws on a bad REACTOR_DB_POOL_SIZE_HOST.
+   * Called eagerly it would fail a PGlite-backed server over a value that
+   * path never reads.
+   */
+  hostPoolSize: () => number;
+  logger: ILogger;
+}): Promise<ReactorStorage>;
 /** Derive the remote attachment service config for switchboard's own `/attachments/*` API. */
 export declare function deriveAttachmentServiceConfig(options: Pick<StartServerOptions, "attachmentServiceUrl" | "https">, serverPort: number, renown: IRenown | null): {
   remoteUrl: string;

package/dist/server.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.mts","names":[],"sources":["../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;KAyBY;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KC8BC;EACN;;EAEA;EACA;;;;;;;;;;YC3CM;;YAKA,wBAAwB;EAClC,eAAe;;YAGL;EACV;EACA;EACA;;YAGU;;EAEV;;;;;EAKA;;EAGA;;YAGU;;;;;;;;;;;;;;;;;;;;;EAqBV,UAAU;;;;;;;;EAQV;;;;;;;EAOA;EACA;EACA;;;;;;EAMA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;IAEM;IACA;;;;;;;EASN,WAAW;;EAEX;;;EAGA;;;EAGA;IACE;;;EAGF,UAAU;EACV,kBAAkB;EAClB;EACA;;;;;;EAMA;EACA,SAAS;;;;;;;;;;EAUT;;;;;;;;;;EAUA;;;;;;;;;EASA;IACE;IACA;IACA;;;;;;;;;;;EAWF;IACE;IACA;;;;;;;;;EASF,6BAA6B;;YAGnB;EACV;EACA,SAAS;;EAET,mBAAmB;;EAEnB,+BAA+B;;;EAG/B,mBAAmB;;EAEnB;;EAEA,iBAAiB;;EAEjB;IAAY,SAAS;;;EAErB;;EAEA,QAAQ;;;;;EAKR;;;;;;;;;;;;;EAaA,gBAAgB;;;;KC/MN;EAIV,iBAAiB;;EAEjB,mBAAmB;;EAEnB;;;;;;EAMA,gBAAgB;;EAEhB;;EAEA;IACE;IACA,eAAe,QAAQ;;;EAGzB,sBAAsB;EACtB,SAAS;;;;;;EAMT,SAAS;;;;;EAKT,cAAc,KAAK;;EAEnB,wBAAwB;;wBAsBV,gCACd,gBAAgB,gBAChB,eAAe,sBACf,UAAS;;;;wBC3EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBCoK3B,gBAAgB,eAAe;;wBAoI/B,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAm7BvB,mBAAgB,UAClB,uBACR,QAAQ"}
+{"version":3,"file":"server.d.mts","names":[],"sources":["../src/pglite-version.ts","../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;;;;cASa;KACD,2BAA2B;;;KCe3B;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KCiCC;EACN;;EAEA;EACA;;;;;;;;;;YC9CM;;YAKA,wBAAwB;EAClC,eAAe;;YAGL;EACV;EACA;EACA;;YAGU;;EAEV;;;;;EAKA;;EAGA;;YAGU;;;;;;;;;;;;;;;;;;;;;EAqBV,UAAU;;;;;;;;EAQV;;;;;;;EAOA;EACA;EACA;;;;;;EAMA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;IAEM;IACA;;;;;;;EASN,WAAW;;EAEX;;;EAGA;;;EAGA;IACE;;;EAGF,UAAU;EACV,kBAAkB;EAClB;EACA;;;;;;EAMA;EACA,SAAS;;;;;;;;;;EAUT;;;;;;;;;;EAUA;;;;;;;;;EASA;IACE;IACA;IACA;;;;;;;;;;;EAWF;IACE;IACA;;;;;;;;;EASF,6BAA6B;;YAGnB;EACV;EACA,SAAS;;EAET,mBAAmB;;EAEnB,+BAA+B;;;EAG/B,mBAAmB;;EAEnB;;EAEA,iBAAiB;;EAEjB;IAAY,SAAS;;;EAErB;;EAEA,QAAQ;;;;;EAKR;;;;;;;;;;;;;EAaA,gBAAgB;;;;KC/MN;EAIV,iBAAiB;;EAEjB,mBAAmB;;EAEnB;;;;;;;EAOA,gBAAgB;;EAEhB;;EAEA;IACE;IACA,eAAe,QAAQ;;;EAGzB,sBAAsB;EACtB,SAAS;;;;;;EAMT,SAAS;;;;;EAKT,cAAc,KAAK;;EAEnB,wBAAwB;;wBAsBV,gCACd,gBAAgB,gBAChB,eAAe,sBACf,UAAS;;;;wBC5EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBC0K3B,gBAAgB,eAAe;;;;;;KA6D1C;EACH,QAAQ,OAAO;EACf,qBAAqB;;wBAGD,oBAAoB;EACxC;EACA;EACA,oBAAoB;EACpB;;;;;;;EAOA;EACA,QAAQ;IACN,QAAQ;;wBAwDI,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAy7BvB,mBAAgB,UAClB,uBACR,QAAQ"}

package/dist/server.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as resolveUnsupportedStoredDocuments, i as StoredDocumentsRefusedError, n as isPortAvailable, o as applySwitchboardReactorDefaults, r as startSwitchboard, t as deriveAttachmentServiceConfig } from "./server-Dvw8_NeM.mjs";
-export { StoredDocumentsRefusedError, applySwitchboardReactorDefaults, deriveAttachmentServiceConfig, isPortAvailable, resolveUnsupportedStoredDocuments, startSwitchboard };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b5bdc179-e9e6-50c3-a581-a82e554e7130")}catch(e){}}();
-//# debugId=b5bdc179-e9e6-50c3-a581-a82e554e7130
+import { a as StoredDocumentsRefusedError, i as startSwitchboard, n as deriveAttachmentServiceConfig, o as resolveUnsupportedStoredDocuments, r as isPortAvailable, s as applySwitchboardReactorDefaults, t as createReactorKysely } from "./server-Zz7SqTwO.mjs";
+export { StoredDocumentsRefusedError, applySwitchboardReactorDefaults, createReactorKysely, deriveAttachmentServiceConfig, isPortAvailable, resolveUnsupportedStoredDocuments, startSwitchboard };
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ecf769b3-3c50-5e91-915e-6761e372127f")}catch(e){}}();
+//# debugId=ecf769b3-3c50-5e91-915e-6761e372127f

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/switchboard",
   "type": "module",
-  "version": "6.2.3-dev.49",
+  "version": "6.2.3-dev.50",
   "main": "dist/index.mjs",
   "exports": {
     ".": {
@@ -41,7 +41,7 @@
     "@openfeature/core": "1.9.1",
     "@openfeature/env-var-provider": "0.3.1",
     "@openfeature/server-sdk": "1.19.0",
-    "@powerhousedao/config": "6.2.3-dev.49",
+    "@powerhousedao/config": "6.2.3-dev.50",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
@@ -55,22 +55,22 @@
     "@opentelemetry/sdk-node": "^0.218.0",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@opentelemetry/semantic-conventions": "^1.41.1",
-    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.49",
-    "@powerhousedao/reactor": "6.2.3-dev.49",
-    "@powerhousedao/shared": "6.2.3-dev.49",
-    "@powerhousedao/vetra": "6.2.3-dev.49",
-    "@powerhousedao/reactor-api": "6.2.3-dev.49",
-    "@powerhousedao/reactor-attachments": "6.2.3-dev.49",
-    "@powerhousedao/reactor-drive": "6.2.3-dev.49",
-    "@powerhousedao/reactor-group": "6.2.3-dev.49",
-    "@powerhousedao/reactor-privacy": "6.2.3-dev.49",
-    "@powerhousedao/reactor-workflow": "6.2.3-dev.49",
-    "@powerhousedao/workflow": "6.2.3-dev.49",
+    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.50",
+    "@powerhousedao/reactor": "6.2.3-dev.50",
+    "@powerhousedao/shared": "6.2.3-dev.50",
+    "@powerhousedao/vetra": "6.2.3-dev.50",
+    "@powerhousedao/reactor-api": "6.2.3-dev.50",
+    "@powerhousedao/reactor-attachments": "6.2.3-dev.50",
+    "@powerhousedao/reactor-drive": "6.2.3-dev.50",
+    "@powerhousedao/reactor-group": "6.2.3-dev.50",
+    "@powerhousedao/reactor-privacy": "6.2.3-dev.50",
+    "@powerhousedao/reactor-workflow": "6.2.3-dev.50",
+    "@powerhousedao/workflow": "6.2.3-dev.50",
     "@pyroscope/nodejs": "^0.4.5",
-    "@renown/sdk": "6.2.3-dev.49",
+    "@renown/sdk": "6.2.3-dev.50",
     "@sentry/node": "^10.53.1",
     "@sentry/opentelemetry": "^10.53.1",
-    "document-model": "6.2.3-dev.49",
+    "document-model": "6.2.3-dev.50",
     "dotenv": "^16.4.7",
     "express": "^4.22.1",
     "graphql": "^16",
@@ -88,7 +88,7 @@
     "concurrently": "9.2.1",
     "nodemon": "3.1.11",
     "react": "19.2.6",
-    "vitest": "4.1.1"
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
     "react": ">=19.0.0"

package/test/pglite-dialect.test.ts

@@ -1,7 +1,54 @@
 import { PGlite } from "@electric-sql/pglite";
 import { Kysely, sql } from "kysely";
-import { afterEach, describe, expect, it } from "vitest";
-import { ClosablePGliteDialect } from "../src/pglite-dialect.js";
+import type { ILogger } from "document-model";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createReactorKysely } from "../src/server.mjs";
+import { EventEmitter } from "node:events";
+import { installFatalErrorShutdown } from "../src/fatal-shutdown.mjs";
+import {
+  ClosablePGliteDialect,
+  reactorPgliteDialectOptions,
+} from "../src/pglite-dialect.js";
+
+type Row = { id: number };
+type Schema = { t: Row };
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+/** COMMIT on an aborted transaction silently rolls back unless the dialect guards it. */
+async function commitOfAnAbortedTransaction(
+  db: Kysely<Schema>,
+): Promise<{ outcome: unknown; rows: Row[] }> {
+  await sql`create table t (id int primary key)`.execute(db);
+  const outcome = await db
+    .transaction()
+    .execute(async (trx) => {
+      await sql`insert into t (id) values (1)`.execute(trx);
+      try {
+        await sql`select 1 / 0`.execute(trx);
+      } catch {
+        /* swallowed, exactly as an unrelated caller would */
+      }
+      return "JOB-SUCCEEDED";
+    })
+    .then(
+      (value: unknown) => value,
+      (error: Error) => ({ error: error.message }),
+    );
+  const rows = await sql<Row>`select id from t`.execute(db);
+  return { outcome, rows: rows.rows };
+}
 
 describe("ClosablePGliteDialect", () => {
   const created: PGlite[] = [];
@@ -65,4 +112,86 @@ describe("ClosablePGliteDialect", () => {
 
     await expect(db.destroy()).resolves.toBeUndefined();
   });
+
+  it("refuses to report a commit for an aborted transaction", async () => {
+    const pglite = new PGlite();
+    created.push(pglite);
+    const db = new Kysely<Schema>({
+      dialect: new ClosablePGliteDialect(pglite, {
+        onDiagnostic: () => undefined,
+      }),
+    });
+
+    const { outcome, rows } = await commitOfAnAbortedTransaction(db);
+    expect(outcome).not.toBe("JOB-SUCCEEDED");
+    expect(rows).toEqual([]);
+
+    await db.destroy();
+  });
+});
+
+describe("switchboard's reactor storage factory", () => {
+  it("builds a PGlite kysely with the commit guard", async () => {
+    const storage = await createReactorKysely({
+      reactorDbUrl: undefined,
+      reactorPgliteDir: ".ph/unused-by-the-in-memory-branch",
+      reactorPgliteMajor: 17,
+      inMemory: true,
+      hostPoolSize: () => {
+        throw new Error("the PGlite branch must not read the host pool size");
+      },
+      logger: stubLogger(),
+    });
+
+    const { outcome, rows } = await commitOfAnAbortedTransaction(
+      storage.kysely as unknown as Kysely<Schema>,
+    );
+    expect(outcome).not.toBe("JOB-SUCCEEDED");
+    expect(rows).toEqual([]);
+    expect(storage.poolInstrumentation).toBeUndefined();
+
+    await storage.kysely.destroy();
+  });
+});
+
+describe("a poisoned reactor PGlite session", () => {
+  it("takes the fatal shutdown path", async () => {
+    const emitter = new EventEmitter();
+    const proc = Object.assign(emitter, {
+      pid: 1234,
+      exitCode: undefined as number | undefined,
+      kill: vi.fn(() => true),
+      exit: vi.fn(),
+    });
+    const logger = stubLogger();
+    installFatalErrorShutdown(logger, proc as never);
+
+    const pglite = new PGlite();
+    const dead = new Proxy(pglite, {
+      get(target, prop, receiver) {
+        if (prop === "query") {
+          return (text: string, params?: unknown[]) =>
+            /dead_call/.test(text)
+              ? new Promise(() => undefined)
+              : target.query(text, params);
+        }
+        const value = Reflect.get(target, prop, receiver) as unknown;
+        return typeof value === "function"
+          ? (value as (...args: unknown[]) => unknown).bind(target)
+          : value;
+      },
+    });
+    const db = new Kysely<Schema>({
+      dialect: new ClosablePGliteDialect(dead, {
+        ...reactorPgliteDialectOptions(logger, proc as never),
+        statementTimeoutMs: 50,
+      }),
+    });
+
+    await expect(sql`select 1 as dead_call`.execute(db)).rejects.toThrow();
+
+    expect(proc.kill).toHaveBeenCalledWith(1234, "SIGTERM");
+    expect(proc.exitCode).toBe(1);
+    await pglite.close();
+  });
 });

package/test/workflow-runtime.test.ts

@@ -5,12 +5,14 @@ import { join } from "node:path";
 import {
   ReactorBuilder,
   ReactorClientBuilder,
+  type AttachmentRef,
   type Database,
   type InProcessReactorClientModule,
   type IReadModelCoordinator,
 } from "@powerhousedao/reactor";
 import {
   BaseSubgraph,
+  type CanonicalDocumentId,
   type GraphQLManager,
   type PackagePieceEntry,
 } from "@powerhousedao/reactor-api";
@@ -30,7 +32,7 @@ import { startSwitchboard } from "../src/server.mjs";
 import {
   PH_WORKFLOWS_ENABLED,
   bindPackagePieces,
-  canReadAttachmentRef,
+  attachmentReadPolicy,
   composeWorkflowRuntime,
   assertWorkflowPackageLoadable,
   hostPrincipalOf,
@@ -203,16 +205,98 @@ describe("composeWorkflowRuntime", () => {
     return composed;
   }
 
-  it("lets a step read any well-formed attachment ref", async () => {
-    const hash = "a".repeat(64);
-    // No document references it: runs read attachments as they read documents.
-    expect(await canReadAttachmentRef("wf-1", `attachment://v1:${hash}`)).toBe(
-      true,
+  it("lets a step read a ref only through a document its user may read", async () => {
+    const ref = `attachment://v1:${"a".repeat(64)}`;
+    const asked: unknown[] = [];
+    const policy = attachmentReadPolicy(
+      {
+        canReadAttachment: (request) => {
+          asked.push(request);
+          return Promise.resolve(
+            request.documentId === "doc-b" && request.userAddress === "0xabc"
+              ? {
+                  kind: "allowed",
+                  documentId: "doc-b" as CanonicalDocumentId,
+                  ref: request.attachmentRef as AttachmentRef,
+                }
+              : { kind: "denied" },
+          );
+        },
+        admitCaller: () => Promise.resolve({ kind: "admitted" }),
+      },
+      1,
     );
-    expect(await canReadAttachmentRef("wf-1", `attachment://v2:${hash}`)).toBe(
-      false,
+    const runUser = {
+      address: "0xabc",
+      subject: { address: "0xabc", key: "did:key:z1" },
+    };
+    expect(
+      await policy({
+        workflowId: "wf-1",
+        ref,
+        documentIds: ["doc-a", "doc-b"],
+        runUser,
+      }),
+    ).toBe(true);
+    expect(asked[1]).toEqual({
+      documentId: "doc-b",
+      attachmentRef: ref,
+      userAddress: "0xabc",
+      appKey: "did:key:z1",
+    });
+    // No document to read it through, another user, or not a ref: refused.
+    expect(
+      await policy({ workflowId: "wf-1", ref, documentIds: [], runUser }),
+    ).toBe(false);
+    expect(
+      await policy({
+        workflowId: "wf-1",
+        ref,
+        documentIds: ["doc-b"],
+        runUser: null,
+      }),
+    ).toBe(false);
+    expect(
+      await policy({
+        workflowId: "wf-1",
+        ref: "not-a-ref",
+        documentIds: ["doc-b"],
+        runUser,
+      }),
+    ).toBe(false);
+    expect(
+      await attachmentReadPolicy(undefined)({
+        workflowId: "wf-1",
+        ref,
+        documentIds: ["doc-b"],
+        runUser,
+      }),
+    ).toBe(false);
+  });
+
+  it("waits for the reference index to catch up with the triggering operation", async () => {
+    const ref = `attachment://v1:${"b".repeat(64)}`;
+    let calls = 0;
+    const policy = attachmentReadPolicy(
+      {
+        canReadAttachment: (request) =>
+          Promise.resolve(
+            ++calls < 3
+              ? { kind: "denied" }
+              : {
+                  kind: "allowed",
+                  documentId: request.documentId as CanonicalDocumentId,
+                  ref: request.attachmentRef as AttachmentRef,
+                },
+          ),
+        admitCaller: () => Promise.resolve({ kind: "admitted" }),
+      },
+      1,
     );
-    expect(await canReadAttachmentRef("wf-1", "not-a-ref")).toBe(false);
+    expect(
+      await policy({ workflowId: "wf-1", ref, documentIds: ["doc-a"] }),
+    ).toBe(true);
+    expect(calls).toBe(3);
   });
 
   it("serves a subgraph the GraphQL manager can construct", async () => {