@executor-js/plugin-graphql 0.0.2 → 0.2.1

package/dist/sdk/plugin.d.ts

@@ -1,12 +1,13 @@
 import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
 import type { Layer } from "effect";
-import { type StorageFailure } from "@executor-js/sdk/core";
+import { HttpClient } from "effect/unstable/http";
+import { type PluginCtx, type StorageFailure } from "@executor-js/sdk/core";
 import { type ConfigFileSink } from "@executor-js/config";
-import { GraphqlExtractionError, GraphqlIntrospectionError } from "./errors";
+import { GraphqlIntrospectionError } from "./errors";
 import { type GraphqlStore, type StoredGraphqlSource } from "./store";
-import { type GraphqlSourceAuth, type HeaderValue as HeaderValueValue, type QueryParamValue } from "./types";
+import { GraphqlSourceBindingInput, GraphqlSourceBindingRef, type ConfiguredGraphqlCredentialValue, type GraphqlCredentialInput, type HeaderValue as HeaderValueValue, type GraphqlSourceAuthInput } from "./types";
 export type HeaderValue = HeaderValueValue;
+export type GraphqlCredentialValue = ConfiguredGraphqlCredentialValue;
 export interface GraphqlSourceConfig {
     /** The GraphQL endpoint URL */
     readonly endpoint: string;
@@ -23,50 +24,25 @@ export interface GraphqlSourceConfig {
     readonly introspectionJson?: string;
     /** Namespace for the tools (derived from endpoint if not provided) */
     readonly namespace?: string;
-    /** Headers applied to every request. Values can reference secrets. */
-    readonly headers?: Record<string, HeaderValue>;
-    /** Query parameters applied to every request. Values can reference secrets. */
-    readonly queryParams?: Record<string, QueryParamValue>;
-    /** Optional OAuth2 connection used as a Bearer token for every request. */
-    readonly auth?: GraphqlSourceAuth;
+    /** Headers applied to every request. Direct secrets are rewritten to slots. */
+    readonly headers?: Record<string, GraphqlCredentialInput>;
+    /** Query parameters applied to every request. Direct secrets are rewritten to slots. */
+    readonly queryParams?: Record<string, GraphqlCredentialInput>;
+    /**
+     * Scope that owns any direct credentials supplied on this call. Required
+     * whenever headers/queryParams/auth carry direct secret or connection ids.
+     */
+    readonly credentialTargetScope?: string;
+    /** Optional OAuth2 credential used as a Bearer token for every request. */
+    readonly auth?: GraphqlSourceAuthInput;
 }
 export interface GraphqlUpdateSourceInput {
     readonly name?: string;
     readonly endpoint?: string;
-    readonly headers?: Record<string, HeaderValue>;
-    readonly queryParams?: Record<string, QueryParamValue>;
-    readonly auth?: GraphqlSourceAuth;
-}
-/**
- * Errors any GraphQL extension method may surface. `GraphqlIntrospectionError`
- * and `GraphqlExtractionError` are plugin-domain tagged errors that flow
- * directly to clients (4xx, each carrying its own `HttpApiSchema` status).
- * `StorageFailure` covers raw backend failures (`StorageError` plus
- * `UniqueViolationError`); the HTTP edge (`@executor-js/api`'s `withCapture`)
- * translates `StorageError` to the opaque `InternalError({ traceId })` at
- * Layer composition.
- */
-export type GraphqlExtensionFailure = GraphqlIntrospectionError | GraphqlExtractionError | StorageFailure;
-export interface GraphqlPluginExtension {
-    /** Add a GraphQL endpoint and register its operations as tools */
-    readonly addSource: (config: GraphqlSourceConfig) => Effect.Effect<{
-        readonly toolCount: number;
-        readonly namespace: string;
-    }, GraphqlExtensionFailure>;
-    /** Remove all tools from a previously added GraphQL source by namespace.
-     *  `scope` pins the cleanup to the exact row — without it a shadowed
-     *  outer-scope source with the same namespace could be wiped instead. */
-    readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
-    /** Fetch the full stored source by namespace (or null if missing).
-     *  `scope` returns the exact row at that scope. For fall-through
-     *  reads across the executor's scope stack, use `executor.sources.*`. */
-    readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredGraphqlSource | null, StorageFailure>;
-    /** Update config (endpoint, headers) for an existing GraphQL source.
-     *  Does NOT re-introspect or re-register tools — just patches the
-     *  stored endpoint/headers used at invoke time. `scope` pins the
-     *  mutation to a single row so shadowed rows at other scopes are
-     *  untouched. */
-    readonly updateSource: (namespace: string, scope: string, input: GraphqlUpdateSourceInput) => Effect.Effect<void, StorageFailure>;
+    readonly headers?: Record<string, GraphqlCredentialInput>;
+    readonly queryParams?: Record<string, GraphqlCredentialInput>;
+    readonly credentialTargetScope?: string;
+    readonly auth?: GraphqlSourceAuthInput;
 }
 export interface GraphqlPluginOptions {
     readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
@@ -74,14 +50,30 @@ export interface GraphqlPluginOptions {
      *  (best-effort — file errors are logged, not raised). */
     readonly configFile?: ConfigFileSink;
 }
+declare const makeGraphqlExtension: (ctx: PluginCtx<GraphqlStore>, httpClientLayer: Layer.Layer<HttpClient.HttpClient>, configFile: ConfigFileSink | undefined) => {
+    addSource: (config: GraphqlSourceConfig) => Effect.Effect<{
+        toolCount: number;
+        namespace: string;
+    }, StorageFailure | GraphqlIntrospectionError | import("./errors").GraphqlExtractionError, never>;
+    removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
+    getSource: (namespace: string, scope: string) => Effect.Effect<StoredGraphqlSource | null, StorageFailure, never>;
+    updateSource: (namespace: string, scope: string, input: GraphqlUpdateSourceInput) => Effect.Effect<void, StorageFailure | GraphqlIntrospectionError, never>;
+    listSourceBindings: (sourceId: string, sourceScope: string) => Effect.Effect<readonly GraphqlSourceBindingRef[], StorageFailure, never>;
+    setSourceBinding: (input: GraphqlSourceBindingInput) => Effect.Effect<GraphqlSourceBindingRef, StorageFailure, never>;
+    removeSourceBinding: (sourceId: string, sourceScope: string, slot: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
+};
+export type GraphqlPluginExtension = ReturnType<typeof makeGraphqlExtension>;
 export declare const graphqlPlugin: import("@executor-js/sdk/core").ConfiguredPlugin<"graphql", {
     addSource: (config: GraphqlSourceConfig) => Effect.Effect<{
-        readonly toolCount: number;
-        readonly namespace: string;
-    }, StorageFailure | GraphqlIntrospectionError | GraphqlExtractionError, never>;
+        toolCount: number;
+        namespace: string;
+    }, StorageFailure | GraphqlIntrospectionError | import("./errors").GraphqlExtractionError, never>;
     removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
     getSource: (namespace: string, scope: string) => Effect.Effect<StoredGraphqlSource | null, StorageFailure, never>;
-    updateSource: (namespace: string, scope: string, input: GraphqlUpdateSourceInput) => Effect.Effect<void, StorageFailure, never>;
+    updateSource: (namespace: string, scope: string, input: GraphqlUpdateSourceInput) => Effect.Effect<void, StorageFailure | GraphqlIntrospectionError, never>;
+    listSourceBindings: (sourceId: string, sourceScope: string) => Effect.Effect<readonly GraphqlSourceBindingRef[], StorageFailure, never>;
+    setSourceBinding: (input: GraphqlSourceBindingInput) => Effect.Effect<GraphqlSourceBindingRef, StorageFailure, never>;
+    removeSourceBinding: (sourceId: string, sourceScope: string, slot: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
 }, GraphqlStore, GraphqlPluginOptions, {
     readonly graphql_source: {
         readonly fields: {
@@ -102,16 +94,89 @@ export declare const graphqlPlugin: import("@executor-js/sdk/core").ConfiguredPl
                 readonly type: "string";
                 readonly required: true;
             };
-            readonly headers: {
-                readonly type: "json";
+            readonly auth_kind: {
+                readonly type: ["none", "oauth2"];
+                readonly required: true;
+                readonly defaultValue: "none";
+            };
+            readonly auth_connection_slot: {
+                readonly type: "string";
                 readonly required: false;
             };
-            readonly query_params: {
-                readonly type: "json";
+        };
+    };
+    readonly graphql_source_header: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly kind: {
+                readonly type: ["text", "binding"];
+                readonly required: true;
+            };
+            readonly text_value: {
+                readonly type: "string";
                 readonly required: false;
             };
-            readonly auth: {
-                readonly type: "json";
+            readonly slot_key: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly prefix: {
+                readonly type: "string";
+                readonly required: false;
+            };
+        };
+    };
+    readonly graphql_source_query_param: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly kind: {
+                readonly type: ["text", "binding"];
+                readonly required: true;
+            };
+            readonly text_value: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly slot_key: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly prefix: {
+                readonly type: "string";
                 readonly required: false;
             };
         };
@@ -138,4 +203,5 @@ export declare const graphqlPlugin: import("@executor-js/sdk/core").ConfiguredPl
             };
         };
     };
-}>;
+}, undefined, Layer.Layer<unknown, never, never>, import("effect/unstable/httpapi/HttpApiGroup").Any>;
+export {};

package/dist/sdk/store.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { type StorageDeps, type StorageFailure } from "@executor-js/sdk/core";
-import { OperationBinding, type GraphqlSourceAuth, type HeaderValue, type QueryParamValue } from "./types";
+import { OperationBinding, type ConfiguredGraphqlCredentialValue, type GraphqlSourceAuth } from "./types";
 export declare const graphqlSchema: {
     readonly graphql_source: {
         readonly fields: {
@@ -21,16 +21,89 @@ export declare const graphqlSchema: {
                 readonly type: "string";
                 readonly required: true;
             };
-            readonly headers: {
-                readonly type: "json";
+            readonly auth_kind: {
+                readonly type: ["none", "oauth2"];
+                readonly required: true;
+                readonly defaultValue: "none";
+            };
+            readonly auth_connection_slot: {
+                readonly type: "string";
                 readonly required: false;
             };
-            readonly query_params: {
-                readonly type: "json";
+        };
+    };
+    readonly graphql_source_header: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly kind: {
+                readonly type: ["text", "binding"];
+                readonly required: true;
+            };
+            readonly text_value: {
+                readonly type: "string";
                 readonly required: false;
             };
-            readonly auth: {
-                readonly type: "json";
+            readonly slot_key: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly prefix: {
+                readonly type: "string";
+                readonly required: false;
+            };
+        };
+    };
+    readonly graphql_source_query_param: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly kind: {
+                readonly type: ["text", "binding"];
+                readonly required: true;
+            };
+            readonly text_value: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly slot_key: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly prefix: {
+                readonly type: "string";
                 readonly required: false;
             };
         };
@@ -67,8 +140,8 @@ export interface StoredGraphqlSource {
     readonly scope: string;
     readonly name: string;
     readonly endpoint: string;
-    readonly headers: Record<string, HeaderValue>;
-    readonly queryParams: Record<string, QueryParamValue>;
+    readonly headers: Record<string, ConfiguredGraphqlCredentialValue>;
+    readonly queryParams: Record<string, ConfiguredGraphqlCredentialValue>;
     readonly auth: GraphqlSourceAuth;
 }
 export interface StoredOperation {
@@ -81,8 +154,8 @@ export interface GraphqlStore {
     readonly updateSourceMeta: (namespace: string, scope: string, patch: {
         readonly name?: string;
         readonly endpoint?: string;
-        readonly headers?: Record<string, HeaderValue>;
-        readonly queryParams?: Record<string, QueryParamValue>;
+        readonly headers?: Record<string, ConfiguredGraphqlCredentialValue>;
+        readonly queryParams?: Record<string, ConfiguredGraphqlCredentialValue>;
         readonly auth?: GraphqlSourceAuth;
     }) => Effect.Effect<void, StorageFailure>;
     readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredGraphqlSource | null, StorageFailure>;

package/dist/sdk/types.d.ts

@@ -50,24 +50,128 @@ export declare const QueryParamValue: Schema.Union<readonly [Schema.String, Sche
     readonly prefix: Schema.optional<Schema.String>;
 }>]>;
 export type QueryParamValue = typeof QueryParamValue.Type;
+export declare const ConfiguredGraphqlCredentialValue: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly kind: Schema.Literal<"binding">;
+    readonly slot: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>;
+export type ConfiguredGraphqlCredentialValue = typeof ConfiguredGraphqlCredentialValue.Type;
+export declare const GraphqlCredentialInput: Schema.Union<readonly [Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+    readonly targetScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+}>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly kind: Schema.Literal<"binding">;
+    readonly slot: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>]>;
+export type GraphqlCredentialInput = typeof GraphqlCredentialInput.Type;
+export declare const graphqlHeaderSlot: (name: string) => string;
+export declare const graphqlQueryParamSlot: (name: string) => string;
+export declare const GRAPHQL_OAUTH_CONNECTION_SLOT = "auth:oauth2:connection";
 export declare const GraphqlSourceAuth: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"none">;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"oauth2">;
-    readonly connectionId: Schema.String;
+    readonly connectionSlot: Schema.String;
 }>]>;
 export type GraphqlSourceAuth = typeof GraphqlSourceAuth.Type;
+export declare const GraphqlSourceAuthInput: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"none">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth2">;
+    readonly connectionSlot: Schema.String;
+}>]>, Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth2">;
+    readonly connectionId: Schema.String;
+}>]>;
+export type GraphqlSourceAuthInput = typeof GraphqlSourceAuthInput.Type;
+export declare const GraphqlSourceBindingValue: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"secret">;
+    readonly secretId: Schema.brand<Schema.String, "SecretId">;
+    readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"connection">;
+    readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
+}>]>;
+export type GraphqlSourceBindingValue = typeof GraphqlSourceBindingValue.Type;
+export declare const GraphqlSourceBindingInputSchema: Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly scope: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"secret">;
+        readonly secretId: Schema.brand<Schema.String, "SecretId">;
+        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"connection">;
+        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
+    }>]>;
+}>;
+declare const GraphqlSourceBindingInput_base: Schema.Class<GraphqlSourceBindingInput, Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly scope: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"secret">;
+        readonly secretId: Schema.brand<Schema.String, "SecretId">;
+        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"connection">;
+        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
+    }>]>;
+}>, {}>;
+export declare class GraphqlSourceBindingInput extends GraphqlSourceBindingInput_base {
+}
+declare const GraphqlSourceBindingRef_base: Schema.Class<GraphqlSourceBindingRef, Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScopeId: Schema.brand<Schema.String, "ScopeId">;
+    readonly scopeId: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"secret">;
+        readonly secretId: Schema.brand<Schema.String, "SecretId">;
+        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"connection">;
+        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
+    }>]>;
+    readonly createdAt: Schema.Date;
+    readonly updatedAt: Schema.Date;
+}>, {}>;
+export declare class GraphqlSourceBindingRef extends GraphqlSourceBindingRef_base {
+}
 declare const InvocationConfig_base: Schema.Class<InvocationConfig, Schema.Struct<{
     /** The GraphQL endpoint URL */
     readonly endpoint: Schema.String;
     /** Headers applied to every request. Values can reference secrets. */
     readonly headers: Schema.withConstructorDefault<Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly secretId: Schema.String;
+        readonly kind: Schema.Literal<"binding">;
+        readonly slot: Schema.String;
         readonly prefix: Schema.optional<Schema.String>;
     }>]>>>>;
     /** Query parameters applied to every request. Values can reference secrets. */
     readonly queryParams: Schema.withConstructorDefault<Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly secretId: Schema.String;
+        readonly kind: Schema.Literal<"binding">;
+        readonly slot: Schema.String;
         readonly prefix: Schema.optional<Schema.String>;
     }>]>>>>;
 }>, {}>;

package/dist/testing/index.d.ts

@@ -0,0 +1,52 @@
+import { Context, Effect, Layer, Schema as EffectSchema, Scope } from "effect";
+import { GraphQLSchema } from "graphql";
+declare const GraphqlRequestPayload: EffectSchema.Struct<{
+    readonly query: EffectSchema.optional<EffectSchema.String>;
+    readonly variables: EffectSchema.optional<EffectSchema.$Record<EffectSchema.String, EffectSchema.Unknown>>;
+    readonly operationName: EffectSchema.optional<EffectSchema.NullOr<EffectSchema.String>>;
+}>;
+type GraphqlRequestPayload = typeof GraphqlRequestPayload.Type;
+export interface GraphqlTestRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly payload: GraphqlRequestPayload;
+}
+export interface GraphqlTestContext {
+    readonly request: GraphqlTestRequest;
+}
+export interface GraphqlTestServerOptions {
+    readonly schema: GraphQLSchema;
+    readonly path?: string;
+}
+export interface GraphqlTestServerShape {
+    readonly endpoint: string;
+    readonly schema: GraphQLSchema;
+    readonly requests: Effect.Effect<readonly GraphqlTestRequest[]>;
+    readonly clearRequests: Effect.Effect<void>;
+}
+declare const GraphqlTestServerAddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GraphqlTestServerAddressError";
+} & Readonly<A>;
+declare class GraphqlTestServerAddressError extends GraphqlTestServerAddressError_base<{
+    readonly address: unknown;
+}> {
+}
+declare const GraphqlTestServerHandlerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GraphqlTestServerHandlerError";
+} & Readonly<A>;
+declare class GraphqlTestServerHandlerError extends GraphqlTestServerHandlerError_base<{
+    readonly cause: unknown;
+}> {
+}
+export declare const serveGraphqlTestServer: (options: GraphqlTestServerOptions) => Effect.Effect<GraphqlTestServerShape, GraphqlTestServerAddressError | GraphqlTestServerHandlerError, Scope.Scope>;
+declare const GraphqlTestServer_base: Context.ServiceClass<GraphqlTestServer, "@executor-js/plugin-graphql/testing/GraphqlTestServer", GraphqlTestServerShape>;
+export declare class GraphqlTestServer extends GraphqlTestServer_base {
+    static readonly layer: (options: GraphqlTestServerOptions) => Layer.Layer<GraphqlTestServer, GraphqlTestServerAddressError | GraphqlTestServerHandlerError, never>;
+}
+export declare const makeGreetingGraphqlSchema: () => GraphQLSchema;
+export declare const TestLayers: {
+    greeting: () => Layer.Layer<GraphqlTestServer, GraphqlTestServerAddressError | GraphqlTestServerHandlerError, never>;
+};
+export {};

package/dist/testing.js

@@ -0,0 +1,131 @@
+// src/testing/index.ts
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Predicate,
+  Ref,
+  Schema as EffectSchema
+} from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString } from "graphql";
+import { createYoga } from "graphql-yoga";
+import { serveTestHttpApp } from "@executor-js/sdk/testing";
+var GraphqlRequestPayload = EffectSchema.Struct({
+  query: EffectSchema.optional(EffectSchema.String),
+  variables: EffectSchema.optional(EffectSchema.Record(EffectSchema.String, EffectSchema.Unknown)),
+  operationName: EffectSchema.optional(EffectSchema.NullOr(EffectSchema.String))
+});
+var GraphqlTestServerAddressError = class extends Data.TaggedError("GraphqlTestServerAddressError") {
+};
+var GraphqlTestServerHandlerError = class extends Data.TaggedError("GraphqlTestServerHandlerError") {
+};
+var headersFromRequest = (headers) => Object.fromEntries(headers.entries());
+var payloadFromParams = (params) => ({
+  query: params.query,
+  variables: typeof params.variables === "object" && params.variables !== null ? params.variables : void 0,
+  operationName: params.operationName ?? null
+});
+var captureRequest = (initial, requests) => {
+  const url = new URL(initial.request.url);
+  const captured = {
+    url: initial.request.url,
+    method: initial.request.method,
+    path: url.pathname,
+    headers: headersFromRequest(initial.request.headers),
+    payload: payloadFromParams(initial.params)
+  };
+  return Effect.runPromise(
+    Ref.update(requests, (all) => [...all, captured]).pipe(Effect.as(captured))
+  );
+};
+var serveGraphqlTestServer = (options) => Effect.gen(function* () {
+  const requests = yield* Ref.make([]);
+  const path = options.path ?? "/graphql";
+  const yoga = createYoga({
+    schema: options.schema,
+    graphqlEndpoint: path,
+    graphiql: false,
+    landingPage: false,
+    logging: false,
+    maskedErrors: false,
+    context: (initial) => captureRequest(initial, requests).then((request) => ({
+      request
+    }))
+  });
+  const server = yield* serveTestHttpApp(
+    (request) => Effect.gen(function* () {
+      const webRequest = yield* HttpServerRequest.toWeb(request);
+      const response = yield* Effect.promise(() => Promise.resolve(yoga.handle(webRequest, {})));
+      return HttpServerResponse.fromWeb(response);
+    }).pipe(
+      Effect.catch(
+        () => Effect.succeed(
+          HttpServerResponse.text("GraphQL test server failed", {
+            status: 500,
+            contentType: "text/plain"
+          })
+        )
+      )
+    )
+  ).pipe(
+    Effect.mapError(
+      (error) => Predicate.isTagged(error, "TestHttpServerAddressError") ? new GraphqlTestServerAddressError({ address: error.address }) : new GraphqlTestServerHandlerError({ cause: error.cause })
+    )
+  );
+  return {
+    endpoint: server.url(path),
+    schema: options.schema,
+    requests: Ref.get(requests),
+    clearRequests: Ref.set(requests, [])
+  };
+});
+var GraphqlTestServer = class _GraphqlTestServer extends Context.Service()(
+  "@executor-js/plugin-graphql/testing/GraphqlTestServer"
+) {
+  static layer = (options) => Layer.effect(_GraphqlTestServer, serveGraphqlTestServer(options));
+};
+var stringArgument = (args, key, fallback) => {
+  const value = args[key];
+  return typeof value === "string" ? value : fallback;
+};
+var makeGreetingGraphqlSchema = () => {
+  const Query = new GraphQLObjectType({
+    name: "Query",
+    fields: {
+      hello: {
+        type: GraphQLString,
+        description: "Say hello",
+        args: {
+          name: { type: GraphQLString }
+        },
+        resolve: (_source, args) => `Hello ${stringArgument(args, "name", "world")}`
+      }
+    }
+  });
+  const Mutation = new GraphQLObjectType({
+    name: "Mutation",
+    fields: {
+      setGreeting: {
+        type: GraphQLString,
+        description: "Set greeting message",
+        args: {
+          message: { type: new GraphQLNonNull(GraphQLString) }
+        },
+        resolve: (_source, args) => stringArgument(args, "message", "")
+      }
+    }
+  });
+  return new GraphQLSchema({ query: Query, mutation: Mutation });
+};
+var TestLayers = {
+  greeting: () => GraphqlTestServer.layer({ schema: makeGreetingGraphqlSchema() })
+};
+export {
+  GraphqlTestServer,
+  TestLayers,
+  makeGreetingGraphqlSchema,
+  serveGraphqlTestServer
+};
+//# sourceMappingURL=testing.js.map