@executor-js/plugin-graphql 0.0.1 → 0.0.2

package/dist/sdk/plugin.d.ts

@@ -1,13 +1,22 @@
 import { Effect } from "effect";
-import { HttpClient } from "@effect/platform";
+import { HttpClient } from "effect/unstable/http";
 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 { 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 +25,117 @@ 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;
+            };
+        };
+    };
+}>;

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;

package/dist/sdk/types.d.ts

@@ -1,172 +1,83 @@
 import { Schema } from "effect";
-export declare const GraphqlOperationKind: Schema.Literal<["query", "mutation"]>;
+export declare const GraphqlOperationKind: Schema.Literals<readonly ["query", "mutation"]>;
 export type GraphqlOperationKind = typeof GraphqlOperationKind.Type;
-declare const GraphqlArgument_base: Schema.Class<GraphqlArgument, {
-    name: typeof Schema.String;
-    typeName: typeof Schema.String;
-    required: typeof Schema.Boolean;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    typeName: typeof Schema.String;
-    required: typeof Schema.Boolean;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly description: import("effect/Option").Option<string>;
-} & {
-    readonly required: boolean;
-} & {
-    readonly typeName: string;
-}, {}, {}>;
+declare const GraphqlArgument_base: Schema.Class<GraphqlArgument, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly typeName: Schema.String;
+    readonly required: Schema.Boolean;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+}>, {}>;
 export declare class GraphqlArgument extends GraphqlArgument_base {
 }
-declare const ExtractedField_base: Schema.Class<ExtractedField, {
+declare const ExtractedField_base: Schema.Class<ExtractedField, Schema.Struct<{
     /** e.g. "user", "createUser" */
-    fieldName: typeof Schema.String;
+    readonly fieldName: Schema.String;
     /** "query" or "mutation" */
-    kind: Schema.Literal<["query", "mutation"]>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    arguments: Schema.Array$<typeof GraphqlArgument>;
+    readonly kind: Schema.Literals<readonly ["query", "mutation"]>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+    readonly arguments: Schema.$Array<typeof GraphqlArgument>;
     /** JSON Schema for the input (built from arguments) */
-    inputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
+    readonly inputSchema: Schema.OptionFromOptional<Schema.Unknown>;
     /** The return type name for documentation */
-    returnTypeName: typeof Schema.String;
-}, Schema.Struct.Encoded<{
-    /** e.g. "user", "createUser" */
-    fieldName: typeof Schema.String;
-    /** "query" or "mutation" */
-    kind: Schema.Literal<["query", "mutation"]>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    arguments: Schema.Array$<typeof GraphqlArgument>;
-    /** JSON Schema for the input (built from arguments) */
-    inputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    /** The return type name for documentation */
-    returnTypeName: typeof Schema.String;
-}>, never, {
-    readonly description: import("effect/Option").Option<string>;
-} & {
-    readonly inputSchema: import("effect/Option").Option<unknown>;
-} & {
-    readonly kind: "query" | "mutation";
-} & {
-    readonly fieldName: string;
-} & {
-    readonly returnTypeName: string;
-} & {
-    readonly arguments: readonly GraphqlArgument[];
-}, {}, {}>;
+    readonly returnTypeName: Schema.String;
+}>, {}>;
 export declare class ExtractedField extends ExtractedField_base {
 }
-declare const ExtractionResult_base: Schema.Class<ExtractionResult, {
-    /** Schema name from introspection */
-    schemaName: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    fields: Schema.Array$<typeof ExtractedField>;
-}, Schema.Struct.Encoded<{
+declare const ExtractionResult_base: Schema.Class<ExtractionResult, Schema.Struct<{
     /** Schema name from introspection */
-    schemaName: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    fields: Schema.Array$<typeof ExtractedField>;
-}>, never, {
-    readonly fields: readonly ExtractedField[];
-} & {
-    readonly schemaName: import("effect/Option").Option<string>;
-}, {}, {}>;
+    readonly schemaName: Schema.OptionFromOptional<Schema.String>;
+    readonly fields: Schema.$Array<typeof ExtractedField>;
+}>, {}>;
 export declare class ExtractionResult extends ExtractionResult_base {
 }
-declare const OperationBinding_base: Schema.Class<OperationBinding, {
-    kind: Schema.Literal<["query", "mutation"]>;
-    fieldName: typeof Schema.String;
+declare const OperationBinding_base: Schema.Class<OperationBinding, Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["query", "mutation"]>;
+    readonly fieldName: Schema.String;
     /** The full GraphQL query/mutation string */
-    operationString: typeof Schema.String;
+    readonly operationString: Schema.String;
     /** Ordered variable names for mapping */
-    variableNames: Schema.Array$<typeof Schema.String>;
-}, Schema.Struct.Encoded<{
-    kind: Schema.Literal<["query", "mutation"]>;
-    fieldName: typeof Schema.String;
-    /** The full GraphQL query/mutation string */
-    operationString: typeof Schema.String;
-    /** Ordered variable names for mapping */
-    variableNames: Schema.Array$<typeof Schema.String>;
-}>, never, {
-    readonly kind: "query" | "mutation";
-} & {
-    readonly fieldName: string;
-} & {
-    readonly operationString: string;
-} & {
-    readonly variableNames: readonly string[];
-}, {}, {}>;
+    readonly variableNames: Schema.$Array<Schema.String>;
+}>, {}>;
 export declare class OperationBinding extends OperationBinding_base {
 }
-export declare const HeaderValue: Schema.Union<[typeof Schema.String, Schema.Struct<{
-    secretId: typeof Schema.String;
-    prefix: Schema.optional<typeof Schema.String>;
+export declare const HeaderValue: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
 }>]>;
 export type HeaderValue = typeof HeaderValue.Type;
-declare const InvocationConfig_base: Schema.Class<InvocationConfig, {
-    /** The GraphQL endpoint URL */
-    endpoint: typeof Schema.String;
-    /** Headers applied to every request. Values can reference secrets. */
-    headers: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Struct<{
-        secretId: typeof Schema.String;
-        prefix: Schema.optional<typeof Schema.String>;
-    }>]>>, {
-        default: () => {};
-    }>;
-}, Schema.Struct.Encoded<{
+export declare const QueryParamValue: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>;
+export type QueryParamValue = typeof QueryParamValue.Type;
+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;
+}>]>;
+export type GraphqlSourceAuth = typeof GraphqlSourceAuth.Type;
+declare const InvocationConfig_base: Schema.Class<InvocationConfig, Schema.Struct<{
     /** The GraphQL endpoint URL */
-    endpoint: typeof Schema.String;
+    readonly endpoint: Schema.String;
     /** Headers applied to every request. Values can reference secrets. */
-    headers: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Struct<{
-        secretId: typeof Schema.String;
-        prefix: Schema.optional<typeof Schema.String>;
-    }>]>>, {
-        default: () => {};
-    }>;
-}>, never, {
-    readonly endpoint: string;
-} & {
-    readonly headers?: {
-        readonly [x: string]: string | {
-            readonly secretId: string;
-            readonly prefix?: string | undefined;
-        };
-    } | undefined;
-}, {}, {}>;
+    readonly headers: Schema.withConstructorDefault<Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly secretId: 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 prefix: Schema.optional<Schema.String>;
+    }>]>>>>;
+}>, {}>;
 export declare class InvocationConfig extends InvocationConfig_base {
 }
-declare const InvocationResult_base: Schema.Class<InvocationResult, {
-    status: typeof Schema.Number;
-    data: Schema.NullOr<typeof Schema.Unknown>;
-    errors: Schema.NullOr<typeof Schema.Unknown>;
-}, Schema.Struct.Encoded<{
-    status: typeof Schema.Number;
-    data: Schema.NullOr<typeof Schema.Unknown>;
-    errors: Schema.NullOr<typeof Schema.Unknown>;
-}>, never, {
-    readonly data: unknown;
-} & {
-    readonly status: number;
-} & {
-    readonly errors: unknown;
-}, {}, {}>;
+declare const InvocationResult_base: Schema.Class<InvocationResult, Schema.Struct<{
+    readonly status: Schema.Number;
+    readonly data: Schema.NullOr<Schema.Unknown>;
+    readonly errors: Schema.NullOr<Schema.Unknown>;
+}>, {}>;
 export declare class InvocationResult extends InvocationResult_base {
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executor-js/plugin-graphql",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/plugins/graphql",
   "bugs": {
     "url": "https://github.com/RhysSullivan/executor/issues"
@@ -40,28 +40,23 @@
     "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@effect/platform": "^0.96.0",
-    "@effect/platform-node": "^0.106.0",
-    "@executor/config": "1.4.3",
-    "@executor-js/sdk": "0.0.1",
-    "effect": "^3.21.0"
+    "@effect/platform-node": "4.0.0-beta.59",
+    "@executor-js/config": "0.0.2",
+    "@executor-js/sdk": "0.0.2",
+    "effect": "4.0.0-beta.59"
   },
   "devDependencies": {
-    "@effect-atom/atom-react": "^0.5.0",
-    "@effect/vitest": "^0.29.0",
-    "@executor/api": "1.4.3",
-    "@executor/react": "1.4.3",
+    "@effect/atom-react": "4.0.0-beta.59",
+    "@effect/vitest": "4.0.0-beta.59",
     "@types/node": "^24.3.1",
     "@types/react": "^19.1.0",
     "bun-types": "^1.2.22",
     "react": "^19.1.0",
     "tsup": "^8.5.0",
-    "vitest": "^4.1.3"
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "@effect-atom/atom-react": "^0.5.0",
-    "@executor/api": "1.4.3",
-    "@executor/react": "1.4.3",
+    "@effect/atom-react": "4.0.0-beta.59",
     "@tanstack/react-router": "^1.168.10",
     "react": "^19.1.0"
   },
@@ -69,17 +64,11 @@
     "react": {
       "optional": true
     },
-    "@effect-atom/atom-react": {
+    "@effect/atom-react": {
       "optional": true
     },
     "@tanstack/react-router": {
       "optional": true
-    },
-    "@executor/api": {
-      "optional": true
-    },
-    "@executor/react": {
-      "optional": true
     }
   }
 }