@executor-js/plugin-graphql 0.0.1 → 0.1.0

package/dist/sdk/index.d.ts

@@ -1,9 +1,7 @@
 export { introspect, parseIntrospectionJson } from "./introspect";
 export { extract, type ExtractionOutput } from "./extract";
-export { invoke, makeGraphqlInvoker } from "./invoke";
-export { graphqlPlugin, type GraphqlSourceConfig, type GraphqlPluginExtension } from "./plugin";
-export { type GraphqlOperationStore, type StoredSource, type SourceConfig, } from "./operation-store";
-export { makeKvOperationStore, makeInMemoryOperationStore } from "./kv-operation-store";
-export { withConfigFile } from "./config-file-store";
+export { invoke, invokeWithLayer, resolveHeaders } from "./invoke";
+export { graphqlPlugin, type GraphqlSourceConfig, type GraphqlPluginExtension, type GraphqlPluginOptions, type GraphqlUpdateSourceInput, } from "./plugin";
+export { graphqlSchema, makeDefaultGraphqlStore, type GraphqlSchema, type GraphqlStore, type StoredGraphqlSource, type StoredOperation, } from "./store";
 export { GraphqlIntrospectionError, GraphqlExtractionError, GraphqlInvocationError, } from "./errors";
-export { ExtractedField, ExtractionResult, GraphqlArgument, GraphqlOperationKind, InvocationConfig, InvocationResult, OperationBinding, HeaderValue, } from "./types";
+export { ExtractedField, ExtractionResult, GraphqlArgument, GraphqlOperationKind, GraphqlSourceAuth, InvocationConfig, InvocationResult, OperationBinding, HeaderValue, type QueryParamValue, } from "./types";

package/dist/sdk/introspect.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { HttpClient } from "@effect/platform";
+import { HttpClient } from "effect/unstable/http";
 import { GraphqlIntrospectionError } from "./errors";
 export interface IntrospectionTypeRef {
     readonly kind: string;
@@ -42,5 +42,5 @@ export interface IntrospectionSchema {
 export interface IntrospectionResult {
     readonly __schema: IntrospectionSchema;
 }
-export declare const introspect: (endpoint: string, headers?: Record<string, string> | undefined) => Effect.Effect<IntrospectionResult, GraphqlIntrospectionError, HttpClient.HttpClient>;
+export declare const introspect: (endpoint: string, headers?: Record<string, string> | undefined, queryParams?: Record<string, string> | undefined) => Effect.Effect<IntrospectionResult, GraphqlIntrospectionError, HttpClient.HttpClient>;
 export declare const parseIntrospectionJson: (text: string) => Effect.Effect<IntrospectionResult, GraphqlIntrospectionError>;

package/dist/sdk/invoke.d.ts

@@ -1,15 +1,9 @@
 import { Effect, Layer } from "effect";
-import { HttpClient } from "@effect/platform";
-import { type ToolInvoker, type ScopeId, type SecretId } from "@executor-js/sdk";
+import { HttpClient } from "effect/unstable/http";
 import { GraphqlInvocationError } from "./errors";
-import type { GraphqlOperationStore } from "./operation-store";
-import { type OperationBinding, InvocationConfig, InvocationResult } from "./types";
-export declare const invoke: (operation: OperationBinding, args: Record<string, unknown>, config: InvocationConfig, resolvedHeaders?: Record<string, string> | undefined) => Effect.Effect<InvocationResult, GraphqlInvocationError | import("@effect/platform/HttpClientError").ResponseError, HttpClient.HttpClient>;
-export declare const makeGraphqlInvoker: (opts: {
-    readonly operationStore: GraphqlOperationStore;
-    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient>;
-    readonly secrets: {
-        readonly resolve: (secretId: SecretId, scopeId: ScopeId) => Effect.Effect<string, unknown>;
-    };
-    readonly scopeId: ScopeId;
-}) => ToolInvoker;
+import { type HeaderValue, type OperationBinding, InvocationResult } from "./types";
+export declare const resolveHeaders: (headers: Record<string, HeaderValue>, secrets: {
+    readonly get: (id: string) => Effect.Effect<string | null, unknown>;
+}) => Effect.Effect<Record<string, string>>;
+export declare const invoke: (operation: OperationBinding, args: Record<string, unknown>, endpoint: string, resolvedHeaders: Record<string, string>, resolvedQueryParams?: Record<string, string> | undefined) => Effect.Effect<InvocationResult, GraphqlInvocationError | import("effect/unstable/http/HttpClientError").HttpClientError, HttpClient.HttpClient>;
+export declare const invokeWithLayer: (operation: OperationBinding, args: Record<string, unknown>, endpoint: string, resolvedHeaders: Record<string, string>, resolvedQueryParams: Record<string, string>, httpClientLayer: Layer.Layer<HttpClient.HttpClient>) => Effect.Effect<InvocationResult, GraphqlInvocationError, never>;

package/dist/sdk/plugin.d.ts

@@ -1,13 +1,23 @@
 import { Effect } from "effect";
-import { HttpClient } from "@effect/platform";
 import type { Layer } from "effect";
-import { type ExecutorPlugin } from "@executor-js/sdk";
-import type { GraphqlOperationStore, StoredSource } from "./operation-store";
-import { type HeaderValue as HeaderValueValue } from "./types";
+import { HttpClient } from "effect/unstable/http";
+import { GraphqlExtensionService } from "../api/handlers";
+import { type StorageFailure } from "@executor-js/sdk/core";
+import { type ConfigFileSink } from "@executor-js/config";
+import { GraphqlExtractionError, GraphqlIntrospectionError } from "./errors";
+import { type GraphqlStore, type StoredGraphqlSource } from "./store";
+import { type GraphqlSourceAuth, type HeaderValue as HeaderValueValue, type QueryParamValue } from "./types";
 export type HeaderValue = HeaderValueValue;
 export interface GraphqlSourceConfig {
     /** The GraphQL endpoint URL */
     readonly endpoint: string;
+    /**
+     * Executor scope id that owns this source row. Must be one of the
+     * executor's configured scopes. Typical shape: an admin adds the
+     * source at the outermost (organization) scope so it's visible to
+     * every inner (per-user) scope via fall-through reads.
+     */
+    readonly scope: string;
     /** Display name for the source. Falls back to namespace if not provided. */
     readonly name?: string;
     /** Optional: introspection JSON text (if endpoint doesn't support introspection) */
@@ -16,25 +26,232 @@ export interface GraphqlSourceConfig {
     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;
 }
 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;
-    }, Error>;
-    /** Remove all tools from a previously added GraphQL source by namespace */
-    readonly removeSource: (namespace: string) => Effect.Effect<void>;
-    /** Fetch the full stored source by namespace (or null if missing) */
-    readonly getSource: (namespace: string) => Effect.Effect<StoredSource | null>;
-    /** Update config (endpoint, headers) for an existing GraphQL source */
-    readonly updateSource: (namespace: string, input: GraphqlUpdateSourceInput) => Effect.Effect<void>;
+        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>;
 }
-export declare const graphqlPlugin: (options?: {
+export interface GraphqlPluginOptions {
     readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
-    readonly operationStore?: GraphqlOperationStore;
-}) => ExecutorPlugin<"graphql", GraphqlPluginExtension>;
+    /** If provided, source add/remove is mirrored to executor.jsonc
+     *  (best-effort — file errors are logged, not raised). */
+    readonly configFile?: ConfigFileSink;
+}
+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>;
+    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>;
+}, GraphqlStore, GraphqlPluginOptions, {
+    readonly graphql_source: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly endpoint: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly headers: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly query_params: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly auth: {
+                readonly type: "json";
+                readonly required: false;
+            };
+        };
+    };
+    readonly graphql_operation: {
+        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 binding: {
+                readonly type: "json";
+                readonly required: true;
+            };
+        };
+    };
+}, typeof GraphqlExtensionService, Layer.Layer<import("effect/unstable/httpapi/HttpApiGroup").ApiGroup<"executor", "graphql">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", GraphqlExtensionService>>, import("effect/unstable/httpapi/HttpApiGroup").HttpApiGroup<"graphql", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"addSource", "POST", "/scopes/:scopeId/graphql/sources", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly endpoint: import("effect/Schema").String;
+    readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly introspectionJson: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly namespace: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+    readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+    readonly auth: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly connectionId: import("effect/Schema").String;
+    }>]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly toolCount: import("effect/Schema").Number;
+    readonly namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlIntrospectionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never> | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlExtractionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never>>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getSource", "GET", "/scopes/:scopeId/graphql/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+    namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+    readonly namespace: import("effect/Schema").String;
+    readonly name: import("effect/Schema").String;
+    readonly endpoint: import("effect/Schema").String;
+    readonly headers: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>]>>;
+    readonly queryParams: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>]>>;
+    readonly auth: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly connectionId: import("effect/Schema").String;
+    }>]>;
+}>>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlIntrospectionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never> | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlExtractionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never>>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"updateSource", "PATCH", "/scopes/:scopeId/graphql/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+    namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly endpoint: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+    readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+    readonly auth: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly connectionId: import("effect/Schema").String;
+    }>]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly updated: import("effect/Schema").Boolean;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlIntrospectionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlIntrospectionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlIntrospectionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never> | import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<GraphqlExtractionError, {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}, readonly [import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>], {
+    readonly message: string;
+    readonly _tag: "GraphqlExtractionError";
+}>, import("effect/Schema").TaggedStruct<"GraphqlExtractionError", {
+    readonly message: import("effect/Schema").String;
+}>, never, never>>, never, never>, false>>;

package/dist/sdk/store.d.ts

@@ -0,0 +1,94 @@
+import { Effect } from "effect";
+import { type StorageDeps, type StorageFailure } from "@executor-js/sdk/core";
+import { OperationBinding, type GraphqlSourceAuth, type HeaderValue, type QueryParamValue } from "./types";
+export declare const graphqlSchema: {
+    readonly graphql_source: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly endpoint: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly headers: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly query_params: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly auth: {
+                readonly type: "json";
+                readonly required: false;
+            };
+        };
+    };
+    readonly graphql_operation: {
+        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 binding: {
+                readonly type: "json";
+                readonly required: true;
+            };
+        };
+    };
+};
+export type GraphqlSchema = typeof graphqlSchema;
+export interface StoredGraphqlSource {
+    readonly namespace: string;
+    /** Executor scope id this source row lives in. Writes stamp this on
+     *  `scope_id`; reads return whichever scope's row the adapter's
+     *  fall-through walk surfaced first. */
+    readonly scope: string;
+    readonly name: string;
+    readonly endpoint: string;
+    readonly headers: Record<string, HeaderValue>;
+    readonly queryParams: Record<string, QueryParamValue>;
+    readonly auth: GraphqlSourceAuth;
+}
+export interface StoredOperation {
+    readonly toolId: string;
+    readonly sourceId: string;
+    readonly binding: OperationBinding;
+}
+export interface GraphqlStore {
+    readonly upsertSource: (input: StoredGraphqlSource, operations: readonly StoredOperation[]) => Effect.Effect<void, StorageFailure>;
+    readonly updateSourceMeta: (namespace: string, scope: string, patch: {
+        readonly name?: string;
+        readonly endpoint?: string;
+        readonly headers?: Record<string, HeaderValue>;
+        readonly queryParams?: Record<string, QueryParamValue>;
+        readonly auth?: GraphqlSourceAuth;
+    }) => Effect.Effect<void, StorageFailure>;
+    readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredGraphqlSource | null, StorageFailure>;
+    readonly listSources: () => Effect.Effect<readonly StoredGraphqlSource[], StorageFailure>;
+    readonly getOperationByToolId: (toolId: string, scope: string) => Effect.Effect<StoredOperation | null, StorageFailure>;
+    readonly listOperationsBySource: (sourceId: string, scope: string) => Effect.Effect<readonly StoredOperation[], StorageFailure>;
+    readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
+}
+export declare const makeDefaultGraphqlStore: ({ adapter: db, }: StorageDeps<GraphqlSchema>) => GraphqlStore;