@executor-js/plugin-graphql 0.0.1 → 0.1.0

package/dist/chunk-EIC5WI6C.js

@@ -0,0 +1,1225 @@
+// src/sdk/errors.ts
+import { Data, Schema } from "effect";
+var GraphqlIntrospectionError = class extends Schema.TaggedErrorClass()(
+  "GraphqlIntrospectionError",
+  {
+    message: Schema.String
+  }
+) {
+};
+var GraphqlExtractionError = class extends Schema.TaggedErrorClass()(
+  "GraphqlExtractionError",
+  {
+    message: Schema.String
+  }
+) {
+};
+var GraphqlInvocationError = class extends Data.TaggedError("GraphqlInvocationError") {
+};
+
+// src/sdk/types.ts
+import { Effect, Schema as Schema2 } from "effect";
+import { SecretBackedValue } from "@executor-js/sdk/core";
+var GraphqlOperationKind = Schema2.Literals(["query", "mutation"]);
+var GraphqlArgument = class extends Schema2.Class("GraphqlArgument")({
+  name: Schema2.String,
+  typeName: Schema2.String,
+  required: Schema2.Boolean,
+  description: Schema2.OptionFromOptional(Schema2.String)
+}) {
+};
+var ExtractedField = class extends Schema2.Class("ExtractedField")({
+  /** e.g. "user", "createUser" */
+  fieldName: Schema2.String,
+  /** "query" or "mutation" */
+  kind: GraphqlOperationKind,
+  description: Schema2.OptionFromOptional(Schema2.String),
+  arguments: Schema2.Array(GraphqlArgument),
+  /** JSON Schema for the input (built from arguments) */
+  inputSchema: Schema2.OptionFromOptional(Schema2.Unknown),
+  /** The return type name for documentation */
+  returnTypeName: Schema2.String
+}) {
+};
+var ExtractionResult = class extends Schema2.Class("ExtractionResult")({
+  /** Schema name from introspection */
+  schemaName: Schema2.OptionFromOptional(Schema2.String),
+  fields: Schema2.Array(ExtractedField)
+}) {
+};
+var OperationBinding = class extends Schema2.Class("OperationBinding")({
+  kind: GraphqlOperationKind,
+  fieldName: Schema2.String,
+  /** The full GraphQL query/mutation string */
+  operationString: Schema2.String,
+  /** Ordered variable names for mapping */
+  variableNames: Schema2.Array(Schema2.String)
+}) {
+};
+var HeaderValue = SecretBackedValue;
+var QueryParamValue = HeaderValue;
+var GraphqlSourceAuth = Schema2.Union(
+  [
+    Schema2.Struct({ kind: Schema2.Literal("none") }),
+    Schema2.Struct({
+      kind: Schema2.Literal("oauth2"),
+      connectionId: Schema2.String
+    })
+  ]
+);
+var InvocationConfig = class extends Schema2.Class("InvocationConfig")({
+  /** The GraphQL endpoint URL */
+  endpoint: Schema2.String,
+  /** Headers applied to every request. Values can reference secrets. */
+  headers: Schema2.Record(Schema2.String, HeaderValue).pipe(
+    Schema2.withDecodingDefault(Effect.succeed({})),
+    Schema2.withConstructorDefault(Effect.succeed({}))
+  ),
+  /** Query parameters applied to every request. Values can reference secrets. */
+  queryParams: Schema2.Record(Schema2.String, QueryParamValue).pipe(
+    Schema2.withDecodingDefault(Effect.succeed({})),
+    Schema2.withConstructorDefault(Effect.succeed({}))
+  )
+}) {
+};
+var InvocationResult = class extends Schema2.Class("InvocationResult")({
+  status: Schema2.Number,
+  data: Schema2.NullOr(Schema2.Unknown),
+  errors: Schema2.NullOr(Schema2.Unknown)
+}) {
+};
+
+// src/sdk/introspect.ts
+import { Effect as Effect2 } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+var INTROSPECTION_QUERY = `
+  query IntrospectionQuery {
+    __schema {
+      queryType { name }
+      mutationType { name }
+      types {
+        kind
+        name
+        description
+        fields(includeDeprecated: false) {
+          name
+          description
+          args {
+            name
+            description
+            type {
+              ...TypeRef
+            }
+            defaultValue
+          }
+          type {
+            ...TypeRef
+          }
+        }
+        inputFields {
+          name
+          description
+          type {
+            ...TypeRef
+          }
+          defaultValue
+        }
+        enumValues(includeDeprecated: false) {
+          name
+          description
+        }
+      }
+    }
+  }
+
+  fragment TypeRef on __Type {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var introspect = Effect2.fn("GraphQL.introspect")(function* (endpoint, headers, queryParams) {
+  const client = yield* HttpClient.HttpClient;
+  const requestEndpoint = queryParams && Object.keys(queryParams).length > 0 ? (() => {
+    const url = new URL(endpoint);
+    for (const [name, value] of Object.entries(queryParams)) {
+      url.searchParams.set(name, value);
+    }
+    return url.toString();
+  })() : endpoint;
+  let request = HttpClientRequest.post(requestEndpoint).pipe(
+    HttpClientRequest.setHeader("Content-Type", "application/json"),
+    HttpClientRequest.bodyJsonUnsafe({
+      query: INTROSPECTION_QUERY
+    })
+  );
+  if (headers) {
+    for (const [k, v] of Object.entries(headers)) {
+      request = HttpClientRequest.setHeader(request, k, v);
+    }
+  }
+  const response = yield* client.execute(request).pipe(
+    Effect2.tapCause((cause) => Effect2.logError("graphql introspection request failed", cause)),
+    Effect2.mapError(
+      (err) => new GraphqlIntrospectionError({
+        message: `Failed to reach GraphQL endpoint: ${err.message}`
+      })
+    )
+  );
+  if (response.status !== 200) {
+    return yield* new GraphqlIntrospectionError({
+      message: `Introspection failed with status ${response.status}`
+    });
+  }
+  const raw = yield* response.json.pipe(
+    Effect2.tapCause(
+      (cause) => Effect2.logError("graphql introspection JSON parse failed", cause)
+    ),
+    Effect2.mapError(
+      () => new GraphqlIntrospectionError({
+        message: `Failed to parse introspection response as JSON`
+      })
+    )
+  );
+  const json = raw;
+  if (json.errors && Array.isArray(json.errors) && json.errors.length > 0) {
+    return yield* new GraphqlIntrospectionError({
+      message: `Introspection returned ${json.errors.length} error(s)`
+    });
+  }
+  if (!json.data?.__schema) {
+    return yield* new GraphqlIntrospectionError({
+      message: "Introspection response missing __schema"
+    });
+  }
+  return json.data;
+});
+var parseIntrospectionJson = (text) => Effect2.try({
+  try: () => {
+    const parsed = JSON.parse(text);
+    const result = parsed.data ?? parsed;
+    if (!result.__schema) {
+      throw new Error("Missing __schema in introspection JSON");
+    }
+    return result;
+  },
+  catch: (err) => new GraphqlIntrospectionError({
+    message: `Failed to parse introspection JSON: ${err instanceof Error ? err.message : String(err)}`
+  })
+});
+
+// src/sdk/extract.ts
+import { Effect as Effect3, Option } from "effect";
+var unwrapTypeName = (ref) => {
+  if (ref.name) return ref.name;
+  if (ref.ofType) return unwrapTypeName(ref.ofType);
+  return "Unknown";
+};
+var isNonNull = (ref) => ref.kind === "NON_NULL";
+var buildDefinitions = (types) => {
+  const defs = {};
+  for (const [name, type] of types) {
+    if (name.startsWith("__")) continue;
+    if (type.kind === "INPUT_OBJECT" && type.inputFields) {
+      const properties = {};
+      const required = [];
+      for (const field of type.inputFields) {
+        const schema = typeRefToJsonSchema(field.type, types);
+        if (field.description) {
+          schema.description = field.description;
+        }
+        properties[field.name] = schema;
+        if (isNonNull(field.type)) {
+          required.push(field.name);
+        }
+      }
+      const def = { type: "object", properties };
+      if (required.length > 0) def.required = required;
+      if (type.description) def.description = type.description;
+      defs[name] = def;
+    }
+    if (type.kind === "ENUM" && type.enumValues) {
+      defs[name] = {
+        type: "string",
+        enum: type.enumValues.map((v) => v.name),
+        ...type.description ? { description: type.description } : {}
+      };
+    }
+  }
+  return defs;
+};
+var typeRefToJsonSchema = (ref, types) => {
+  switch (ref.kind) {
+    case "NON_NULL":
+      return ref.ofType ? typeRefToJsonSchema(ref.ofType, types) : {};
+    case "LIST":
+      return {
+        type: "array",
+        items: ref.ofType ? typeRefToJsonSchema(ref.ofType, types) : {}
+      };
+    case "SCALAR":
+      return scalarToJsonSchema(ref.name ?? "String");
+    case "ENUM":
+      return ref.name ? { $ref: `#/$defs/${ref.name}` } : { type: "string" };
+    case "INPUT_OBJECT":
+      return ref.name ? { $ref: `#/$defs/${ref.name}` } : { type: "object" };
+    case "OBJECT":
+    case "INTERFACE":
+    case "UNION":
+      return { type: "object" };
+    default:
+      return {};
+  }
+};
+var scalarToJsonSchema = (name) => {
+  switch (name) {
+    case "String":
+    case "ID":
+      return { type: "string" };
+    case "Int":
+      return { type: "integer" };
+    case "Float":
+      return { type: "number" };
+    case "Boolean":
+      return { type: "boolean" };
+    default:
+      return { type: "string", description: `Custom scalar: ${name}` };
+  }
+};
+var buildInputSchema = (args, types) => {
+  if (args.length === 0) return void 0;
+  const properties = {};
+  const required = [];
+  for (const arg of args) {
+    const schema = typeRefToJsonSchema(arg.type, types);
+    if (arg.description) {
+      schema.description = arg.description;
+    }
+    properties[arg.name] = schema;
+    if (isNonNull(arg.type)) {
+      required.push(arg.name);
+    }
+  }
+  const inputSchema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) inputSchema.required = required;
+  return inputSchema;
+};
+var formatTypeRef = (ref) => {
+  switch (ref.kind) {
+    case "NON_NULL":
+      return ref.ofType ? `${formatTypeRef(ref.ofType)}!` : "Unknown!";
+    case "LIST":
+      return ref.ofType ? `[${formatTypeRef(ref.ofType)}]` : "[Unknown]";
+    default:
+      return ref.name ?? "Unknown";
+  }
+};
+var extractFields = (_schema, kind, typeName, types) => {
+  if (!typeName) return [];
+  const type = types.get(typeName);
+  if (!type?.fields) return [];
+  return type.fields.filter((f) => !f.name.startsWith("__")).map((field) => {
+    const args = field.args.map(
+      (arg) => new GraphqlArgument({
+        name: arg.name,
+        typeName: formatTypeRef(arg.type),
+        required: isNonNull(arg.type),
+        description: arg.description ? Option.some(arg.description) : Option.none()
+      })
+    );
+    const inputSchema = buildInputSchema(field.args, types);
+    return new ExtractedField({
+      fieldName: field.name,
+      kind,
+      description: field.description ? Option.some(field.description) : Option.none(),
+      arguments: args,
+      inputSchema: inputSchema ? Option.some(inputSchema) : Option.none(),
+      returnTypeName: unwrapTypeName(field.type)
+    });
+  });
+};
+var extract = (introspection) => Effect3.try({
+  try: () => {
+    const schema = introspection.__schema;
+    const typeMap = /* @__PURE__ */ new Map();
+    for (const t of schema.types) {
+      typeMap.set(t.name, t);
+    }
+    const definitions = buildDefinitions(typeMap);
+    const queryFields = extractFields(schema, "query", schema.queryType?.name, typeMap);
+    const mutationFields = extractFields(schema, "mutation", schema.mutationType?.name, typeMap);
+    return {
+      result: new ExtractionResult({
+        schemaName: Option.none(),
+        fields: [...queryFields, ...mutationFields]
+      }),
+      definitions
+    };
+  },
+  catch: (err) => new GraphqlExtractionError({
+    message: `Failed to extract GraphQL schema: ${err instanceof Error ? err.message : String(err)}`
+  })
+});
+
+// src/sdk/invoke.ts
+import { Effect as Effect4, Option as Option2 } from "effect";
+import { HttpClient as HttpClient2, HttpClientRequest as HttpClientRequest2 } from "effect/unstable/http";
+import { resolveSecretBackedMap } from "@executor-js/sdk/core";
+var resolveHeaders = (headers, secrets) => {
+  const entries = Object.entries(headers);
+  const secretCount = entries.reduce(
+    (acc, [, value]) => typeof value === "string" ? acc : acc + 1,
+    0
+  );
+  return resolveSecretBackedMap({
+    values: headers,
+    getSecret: (secretId) => secrets.get(secretId).pipe(Effect4.catch(() => Effect4.succeed(null))),
+    missing: "drop",
+    onMissing: (name) => new GraphqlInvocationError({
+      message: `Missing secret for header "${name}"`,
+      statusCode: Option2.none()
+    })
+  }).pipe(
+    Effect4.catch(() => Effect4.succeed(void 0)),
+    Effect4.map((resolved) => resolved ?? {}),
+    Effect4.withSpan("plugin.graphql.secret.resolve", {
+      attributes: {
+        "plugin.graphql.headers.total": entries.length,
+        "plugin.graphql.headers.secret_count": secretCount
+      }
+    })
+  );
+};
+var endpointWithQueryParams = (endpoint, queryParams) => {
+  if (Object.keys(queryParams).length === 0) return endpoint;
+  const url = new URL(endpoint);
+  for (const [name, value] of Object.entries(queryParams)) {
+    url.searchParams.set(name, value);
+  }
+  return url.toString();
+};
+var isJsonContentType = (ct) => {
+  if (!ct) return false;
+  const normalized = ct.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "application/json" || normalized.includes("+json") || normalized.includes("json");
+};
+var invoke = Effect4.fn("GraphQL.invoke")(function* (operation, args, endpoint, resolvedHeaders, resolvedQueryParams = {}) {
+  const client = yield* HttpClient2.HttpClient;
+  const requestEndpoint = endpointWithQueryParams(endpoint, resolvedQueryParams);
+  yield* Effect4.annotateCurrentSpan({
+    "http.method": "POST",
+    "http.url": requestEndpoint,
+    "plugin.graphql.endpoint": endpoint,
+    "plugin.graphql.operation_kind": operation.kind,
+    "plugin.graphql.field_name": operation.fieldName,
+    "plugin.graphql.headers.resolved_count": Object.keys(resolvedHeaders).length,
+    "plugin.graphql.query_params.resolved_count": Object.keys(resolvedQueryParams).length
+  });
+  const variables = {};
+  for (const varName of operation.variableNames) {
+    if (args[varName] !== void 0) {
+      variables[varName] = args[varName];
+    }
+  }
+  if (typeof args.variables === "object" && args.variables !== null) {
+    Object.assign(variables, args.variables);
+  }
+  let request = HttpClientRequest2.post(requestEndpoint).pipe(
+    HttpClientRequest2.setHeader("Content-Type", "application/json"),
+    HttpClientRequest2.bodyJsonUnsafe({
+      query: operation.operationString,
+      variables: Object.keys(variables).length > 0 ? variables : void 0
+    })
+  );
+  for (const [name, value] of Object.entries(resolvedHeaders)) {
+    request = HttpClientRequest2.setHeader(request, name, value);
+  }
+  const response = yield* client.execute(request).pipe(
+    Effect4.mapError(
+      (err) => new GraphqlInvocationError({
+        message: `GraphQL request failed: ${err.message}`,
+        statusCode: Option2.none(),
+        cause: err
+      })
+    )
+  );
+  const status = response.status;
+  const contentType = response.headers["content-type"] ?? null;
+  const body = isJsonContentType(contentType) ? yield* response.json.pipe(Effect4.catch(() => response.text)) : yield* response.text;
+  const gqlBody = body;
+  const hasErrors = Array.isArray(gqlBody?.errors) && gqlBody.errors.length > 0;
+  yield* Effect4.annotateCurrentSpan({
+    "http.status_code": status,
+    "plugin.graphql.has_errors": hasErrors,
+    "plugin.graphql.error_count": hasErrors ? gqlBody.errors.length : 0
+  });
+  return new InvocationResult({
+    status,
+    data: gqlBody?.data ?? null,
+    errors: hasErrors ? gqlBody.errors : null
+  });
+});
+var invokeWithLayer = (operation, args, endpoint, resolvedHeaders, resolvedQueryParams, httpClientLayer) => invoke(operation, args, endpoint, resolvedHeaders, resolvedQueryParams).pipe(
+  Effect4.provide(httpClientLayer),
+  Effect4.mapError(
+    (err) => err instanceof GraphqlInvocationError ? err : new GraphqlInvocationError({
+      message: err instanceof Error ? err.message : String(err),
+      statusCode: Option2.none(),
+      cause: err
+    })
+  ),
+  Effect4.withSpan("plugin.graphql.invoke", {
+    attributes: {
+      "plugin.graphql.endpoint": endpoint,
+      "plugin.graphql.operation_kind": operation.kind,
+      "plugin.graphql.field_name": operation.fieldName
+    }
+  })
+);
+
+// src/sdk/store.ts
+import { Effect as Effect5 } from "effect";
+import {
+  defineSchema
+} from "@executor-js/sdk/core";
+var graphqlSchema = defineSchema({
+  graphql_source: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      endpoint: { type: "string", required: true },
+      headers: { type: "json", required: false },
+      query_params: { type: "json", required: false },
+      auth: { type: "json", required: false }
+    }
+  },
+  graphql_operation: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      binding: { type: "json", required: true }
+    }
+  }
+});
+var decodeBinding = (value) => {
+  const data = typeof value === "string" ? JSON.parse(value) : value;
+  return new OperationBinding({
+    kind: data.kind,
+    fieldName: data.fieldName,
+    operationString: data.operationString,
+    variableNames: [...data.variableNames]
+  });
+};
+var encodeBinding = (binding) => ({
+  kind: binding.kind,
+  fieldName: binding.fieldName,
+  operationString: binding.operationString,
+  variableNames: [...binding.variableNames]
+});
+var toJsonRecord = (value) => value;
+var decodeHeaders = (value) => {
+  if (value == null) return {};
+  if (typeof value === "string")
+    return JSON.parse(value);
+  return value;
+};
+var decodeQueryParams = (value) => {
+  if (value == null) return {};
+  if (typeof value === "string")
+    return JSON.parse(value);
+  return value;
+};
+var decodeAuth = (value) => {
+  if (value == null) return { kind: "none" };
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  return parsed?.kind === "oauth2" && typeof parsed.connectionId === "string" ? { kind: "oauth2", connectionId: parsed.connectionId } : { kind: "none" };
+};
+var makeDefaultGraphqlStore = ({
+  adapter: db
+}) => {
+  const rowToSource = (row) => ({
+    namespace: row.id,
+    scope: row.scope_id,
+    name: row.name,
+    endpoint: row.endpoint,
+    headers: decodeHeaders(row.headers),
+    queryParams: decodeQueryParams(row.query_params),
+    auth: decodeAuth(row.auth)
+  });
+  const rowToOperation = (row) => ({
+    toolId: row.id,
+    sourceId: row.source_id,
+    binding: decodeBinding(row.binding)
+  });
+  const deleteSource = (namespace, scope) => Effect5.gen(function* () {
+    yield* db.deleteMany({
+      model: "graphql_operation",
+      where: [
+        { field: "source_id", value: namespace },
+        { field: "scope_id", value: scope }
+      ]
+    });
+    yield* db.delete({
+      model: "graphql_source",
+      where: [
+        { field: "id", value: namespace },
+        { field: "scope_id", value: scope }
+      ]
+    });
+  });
+  return {
+    upsertSource: (input, operations) => Effect5.gen(function* () {
+      yield* deleteSource(input.namespace, input.scope);
+      yield* db.create({
+        model: "graphql_source",
+        data: {
+          id: input.namespace,
+          scope_id: input.scope,
+          name: input.name,
+          endpoint: input.endpoint,
+          headers: input.headers,
+          query_params: input.queryParams,
+          auth: toJsonRecord(input.auth)
+        },
+        forceAllowId: true
+      });
+      if (operations.length > 0) {
+        yield* db.createMany({
+          model: "graphql_operation",
+          data: operations.map((op) => ({
+            id: op.toolId,
+            scope_id: input.scope,
+            source_id: op.sourceId,
+            binding: toJsonRecord(encodeBinding(op.binding))
+          })),
+          forceAllowId: true
+        });
+      }
+    }),
+    updateSourceMeta: (namespace, scope, patch) => Effect5.gen(function* () {
+      const existing = yield* db.findOne({
+        model: "graphql_source",
+        where: [
+          { field: "id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      if (!existing) return;
+      const update = {};
+      if (patch.name !== void 0) update.name = patch.name;
+      if (patch.endpoint !== void 0) update.endpoint = patch.endpoint;
+      if (patch.headers !== void 0) {
+        update.headers = patch.headers;
+      }
+      if (patch.queryParams !== void 0) {
+        update.query_params = patch.queryParams;
+      }
+      if (patch.auth !== void 0) {
+        update.auth = toJsonRecord(patch.auth);
+      }
+      if (Object.keys(update).length === 0) return;
+      yield* db.update({
+        model: "graphql_source",
+        where: [
+          { field: "id", value: namespace },
+          { field: "scope_id", value: scope }
+        ],
+        update
+      });
+    }),
+    getSource: (namespace, scope) => db.findOne({
+      model: "graphql_source",
+      where: [
+        { field: "id", value: namespace },
+        { field: "scope_id", value: scope }
+      ]
+    }).pipe(Effect5.map((row) => row ? rowToSource(row) : null)),
+    listSources: () => db.findMany({ model: "graphql_source" }).pipe(Effect5.map((rows) => rows.map(rowToSource))),
+    getOperationByToolId: (toolId, scope) => db.findOne({
+      model: "graphql_operation",
+      where: [
+        { field: "id", value: toolId },
+        { field: "scope_id", value: scope }
+      ]
+    }).pipe(Effect5.map((row) => row ? rowToOperation(row) : null)),
+    listOperationsBySource: (sourceId, scope) => db.findMany({
+      model: "graphql_operation",
+      where: [
+        { field: "source_id", value: sourceId },
+        { field: "scope_id", value: scope }
+      ]
+    }).pipe(Effect5.map((rows) => rows.map(rowToOperation))),
+    removeSource: (namespace, scope) => deleteSource(namespace, scope)
+  };
+};
+
+// src/sdk/plugin.ts
+import { Effect as Effect7, Option as Option3 } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+
+// src/api/group.ts
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Schema as Schema3 } from "effect";
+import { ScopeId } from "@executor-js/sdk/core";
+import { InternalError } from "@executor-js/api";
+var StoredSourceSchema = Schema3.Struct({
+  namespace: Schema3.String,
+  name: Schema3.String,
+  endpoint: Schema3.String,
+  headers: Schema3.Record(Schema3.String, HeaderValue),
+  queryParams: Schema3.Record(Schema3.String, HeaderValue),
+  auth: GraphqlSourceAuth
+});
+var ScopeParams = {
+  scopeId: ScopeId
+};
+var SourceParams = {
+  scopeId: ScopeId,
+  namespace: Schema3.String
+};
+var AddSourcePayload = Schema3.Struct({
+  endpoint: Schema3.String,
+  name: Schema3.optional(Schema3.String),
+  introspectionJson: Schema3.optional(Schema3.String),
+  namespace: Schema3.optional(Schema3.String),
+  headers: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
+  queryParams: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
+  auth: Schema3.optional(GraphqlSourceAuth)
+});
+var UpdateSourcePayload = Schema3.Struct({
+  name: Schema3.optional(Schema3.String),
+  endpoint: Schema3.optional(Schema3.String),
+  headers: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
+  queryParams: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown)),
+  auth: Schema3.optional(GraphqlSourceAuth)
+});
+var UpdateSourceResponse = Schema3.Struct({
+  updated: Schema3.Boolean
+});
+var AddSourceResponse = Schema3.Struct({
+  toolCount: Schema3.Number,
+  namespace: Schema3.String
+});
+var IntrospectionError = GraphqlIntrospectionError.annotate(
+  { httpApiStatus: 400 }
+);
+var ExtractionError = GraphqlExtractionError.annotate(
+  { httpApiStatus: 400 }
+);
+var GraphqlErrors = [InternalError, IntrospectionError, ExtractionError];
+var GraphqlGroup = HttpApiGroup.make("graphql").add(
+  HttpApiEndpoint.post("addSource", "/scopes/:scopeId/graphql/sources", {
+    params: ScopeParams,
+    payload: AddSourcePayload,
+    success: AddSourceResponse,
+    error: GraphqlErrors
+  })
+).add(
+  HttpApiEndpoint.get("getSource", "/scopes/:scopeId/graphql/sources/:namespace", {
+    params: SourceParams,
+    success: Schema3.NullOr(StoredSourceSchema),
+    error: GraphqlErrors
+  })
+).add(
+  HttpApiEndpoint.patch("updateSource", "/scopes/:scopeId/graphql/sources/:namespace", {
+    params: SourceParams,
+    payload: UpdateSourcePayload,
+    success: UpdateSourceResponse,
+    error: GraphqlErrors
+  })
+);
+
+// src/api/handlers.ts
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Context, Effect as Effect6 } from "effect";
+import { addGroup, capture } from "@executor-js/api";
+var GraphqlExtensionService = class extends Context.Service()("GraphqlExtensionService") {
+};
+var ExecutorApiWithGraphql = addGroup(GraphqlGroup);
+var GraphqlHandlers = HttpApiBuilder.group(
+  ExecutorApiWithGraphql,
+  "graphql",
+  (handlers) => handlers.handle(
+    "addSource",
+    ({ params: path, payload }) => capture(
+      Effect6.gen(function* () {
+        const ext = yield* GraphqlExtensionService;
+        const result = yield* ext.addSource({
+          endpoint: payload.endpoint,
+          scope: path.scopeId,
+          name: payload.name,
+          introspectionJson: payload.introspectionJson,
+          namespace: payload.namespace,
+          headers: payload.headers,
+          queryParams: payload.queryParams,
+          auth: payload.auth
+        });
+        return {
+          toolCount: result.toolCount,
+          namespace: result.namespace
+        };
+      })
+    )
+  ).handle(
+    "getSource",
+    ({ params: path }) => capture(
+      Effect6.gen(function* () {
+        const ext = yield* GraphqlExtensionService;
+        return yield* ext.getSource(path.namespace, path.scopeId);
+      })
+    )
+  ).handle(
+    "updateSource",
+    ({ params: path, payload }) => capture(
+      Effect6.gen(function* () {
+        const ext = yield* GraphqlExtensionService;
+        yield* ext.updateSource(path.namespace, path.scopeId, {
+          name: payload.name,
+          endpoint: payload.endpoint,
+          headers: payload.headers,
+          queryParams: payload.queryParams,
+          auth: payload.auth
+        });
+        return { updated: true };
+      })
+    )
+  )
+);
+
+// src/sdk/plugin.ts
+import {
+  definePlugin,
+  SourceDetectionResult
+} from "@executor-js/sdk/core";
+import {
+  headersToConfigValues
+} from "@executor-js/config";
+var namespaceFromEndpoint = (endpoint) => {
+  try {
+    const url = new URL(endpoint);
+    return url.hostname.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
+  } catch {
+    return "graphql";
+  }
+};
+var formatTypeRef2 = (ref) => {
+  switch (ref.kind) {
+    case "NON_NULL":
+      return ref.ofType ? `${formatTypeRef2(ref.ofType)}!` : "Unknown!";
+    case "LIST":
+      return ref.ofType ? `[${formatTypeRef2(ref.ofType)}]` : "[Unknown]";
+    default:
+      return ref.name ?? "Unknown";
+  }
+};
+var unwrapTypeName2 = (ref) => {
+  if (ref.name) return ref.name;
+  if (ref.ofType) return unwrapTypeName2(ref.ofType);
+  return "Unknown";
+};
+var buildSelectionSet = (ref, types, depth, seen) => {
+  if (depth > 2) return "";
+  const leafName = unwrapTypeName2(ref);
+  if (seen.has(leafName)) return "";
+  const objectType = types.get(leafName);
+  if (!objectType?.fields) return "";
+  const kind = objectType.kind;
+  if (kind === "SCALAR" || kind === "ENUM") return "";
+  seen.add(leafName);
+  const subFields = objectType.fields.filter((f) => !f.name.startsWith("__")).slice(0, 12).map((f) => {
+    const sub = buildSelectionSet(f.type, types, depth + 1, seen);
+    return sub ? `${f.name} ${sub}` : f.name;
+  });
+  seen.delete(leafName);
+  return subFields.length > 0 ? `{ ${subFields.join(" ")} }` : "";
+};
+var buildOperationStringForField = (kind, field, types) => {
+  const opType = kind === "query" ? "query" : "mutation";
+  const varDefs = field.args.map((arg) => {
+    const typeName = formatTypeRef2(arg.type);
+    return `$${arg.name}: ${typeName}`;
+  });
+  const argPasses = field.args.map((arg) => `${arg.name}: $${arg.name}`);
+  const selectionSet = buildSelectionSet(field.type, types, 0, /* @__PURE__ */ new Set());
+  const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(", ")})` : "";
+  const argPassStr = argPasses.length > 0 ? `(${argPasses.join(", ")})` : "";
+  return `${opType}${varDefsStr} { ${field.name}${argPassStr}${selectionSet ? ` ${selectionSet}` : ""} }`;
+};
+var prepareOperations = (fields, introspection) => {
+  const typeMap = /* @__PURE__ */ new Map();
+  for (const t of introspection.__schema.types) {
+    typeMap.set(t.name, t);
+  }
+  const fieldMap = /* @__PURE__ */ new Map();
+  const schema = introspection.__schema;
+  for (const rootKind of ["query", "mutation"]) {
+    const typeName = rootKind === "query" ? schema.queryType?.name : schema.mutationType?.name;
+    if (!typeName) continue;
+    const rootType = typeMap.get(typeName);
+    if (!rootType?.fields) continue;
+    for (const f of rootType.fields) {
+      if (!f.name.startsWith("__")) {
+        fieldMap.set(`${rootKind}.${f.name}`, { kind: rootKind, field: f });
+      }
+    }
+  }
+  return fields.map((extracted) => {
+    const prefix = extracted.kind === "mutation" ? "mutation" : "query";
+    const toolPath = `${prefix}.${extracted.fieldName}`;
+    const description = Option3.getOrElse(
+      extracted.description,
+      () => `GraphQL ${extracted.kind}: ${extracted.fieldName} -> ${extracted.returnTypeName}`
+    );
+    const key = `${extracted.kind}.${extracted.fieldName}`;
+    const entry = fieldMap.get(key);
+    const operationString = entry ? buildOperationStringForField(entry.kind, entry.field, typeMap) : `${extracted.kind} { ${extracted.fieldName} }`;
+    const binding = new OperationBinding({
+      kind: extracted.kind,
+      fieldName: extracted.fieldName,
+      operationString,
+      variableNames: extracted.arguments.map((a) => a.name)
+    });
+    return {
+      toolPath,
+      description,
+      inputSchema: Option3.getOrUndefined(extracted.inputSchema),
+      binding
+    };
+  });
+};
+var annotationsFor = (binding) => {
+  if (binding.kind === "mutation") {
+    return {
+      requiresApproval: true,
+      approvalDescription: `mutation ${binding.fieldName}`
+    };
+  }
+  return {};
+};
+var toGraphqlConfigEntry = (namespace, config) => ({
+  kind: "graphql",
+  endpoint: config.endpoint,
+  introspectionJson: config.introspectionJson,
+  namespace,
+  headers: headersToConfigValues(config.headers)
+});
+var graphqlPlugin = definePlugin((options) => {
+  const httpClientLayer = options?.httpClientLayer ?? FetchHttpClient.layer;
+  return {
+    id: "graphql",
+    packageName: "@executor-js/plugin-graphql",
+    schema: graphqlSchema,
+    storage: (deps) => makeDefaultGraphqlStore(deps),
+    extension: (ctx) => {
+      const resolveConfigValues = (values) => Effect7.gen(function* () {
+        if (!values) return void 0;
+        const resolved = yield* resolveHeaders(values, ctx.secrets);
+        return Object.keys(resolved).length > 0 ? resolved : void 0;
+      });
+      const resolveOAuthHeader = (auth) => Effect7.gen(function* () {
+        if (!auth || auth.kind === "none") return void 0;
+        const accessToken = yield* ctx.connections.accessToken(auth.connectionId).pipe(
+          Effect7.mapError(
+            (err) => new GraphqlIntrospectionError({
+              message: `Failed to resolve OAuth connection "${auth.connectionId}": ${"message" in err ? err.message : String(err)}`
+            })
+          )
+        );
+        return { Authorization: `Bearer ${accessToken}` };
+      });
+      const resolveRequestHeaders = (headers, auth) => Effect7.gen(function* () {
+        const resolvedHeaders = yield* resolveConfigValues(headers);
+        const oauthHeader = yield* resolveOAuthHeader(auth);
+        return { ...resolvedHeaders ?? {}, ...oauthHeader ?? {} };
+      });
+      const addSourceInternal = (config) => ctx.transaction(
+        Effect7.gen(function* () {
+          let introspectionResult;
+          if (config.introspectionJson) {
+            introspectionResult = yield* parseIntrospectionJson(
+              config.introspectionJson
+            );
+          } else {
+            const resolvedHeaders = yield* resolveRequestHeaders(
+              config.headers,
+              config.auth
+            );
+            const resolvedQueryParams = yield* resolveConfigValues(
+              config.queryParams
+            );
+            introspectionResult = yield* introspect(
+              config.endpoint,
+              Object.keys(resolvedHeaders).length > 0 ? resolvedHeaders : void 0,
+              resolvedQueryParams
+            ).pipe(Effect7.provide(httpClientLayer));
+          }
+          const { result, definitions } = yield* extract(introspectionResult);
+          const namespace = config.namespace ?? namespaceFromEndpoint(config.endpoint);
+          const prepared = prepareOperations(
+            result.fields,
+            introspectionResult
+          );
+          const displayName = config.name?.trim() || namespace;
+          const storedSource = {
+            namespace,
+            scope: config.scope,
+            name: displayName,
+            endpoint: config.endpoint,
+            headers: config.headers ?? {},
+            queryParams: config.queryParams ?? {},
+            auth: config.auth ?? { kind: "none" }
+          };
+          const storedOps = prepared.map((p) => ({
+            toolId: `${namespace}.${p.toolPath}`,
+            sourceId: namespace,
+            binding: p.binding
+          }));
+          yield* ctx.storage.upsertSource(storedSource, storedOps);
+          yield* ctx.core.sources.register({
+            id: namespace,
+            scope: config.scope,
+            kind: "graphql",
+            name: displayName,
+            url: config.endpoint,
+            canRemove: true,
+            canRefresh: false,
+            canEdit: true,
+            tools: prepared.map((p) => ({
+              name: p.toolPath,
+              description: p.description,
+              inputSchema: p.inputSchema
+            }))
+          });
+          if (Object.keys(definitions).length > 0) {
+            yield* ctx.core.definitions.register({
+              sourceId: namespace,
+              scope: config.scope,
+              definitions
+            });
+          }
+          return { toolCount: prepared.length, namespace };
+        })
+      );
+      const configFile = options?.configFile;
+      return {
+        addSource: (config) => addSourceInternal(config).pipe(
+          Effect7.tap(
+            (result) => configFile ? configFile.upsertSource(
+              toGraphqlConfigEntry(result.namespace, config)
+            ) : Effect7.void
+          )
+        ),
+        removeSource: (namespace, scope) => Effect7.gen(function* () {
+          yield* ctx.transaction(
+            Effect7.gen(function* () {
+              yield* ctx.storage.removeSource(namespace, scope);
+              yield* ctx.core.sources.unregister(namespace);
+            })
+          );
+          if (configFile) {
+            yield* configFile.removeSource(namespace);
+          }
+        }),
+        getSource: (namespace, scope) => ctx.storage.getSource(namespace, scope),
+        updateSource: (namespace, scope, input) => ctx.storage.updateSourceMeta(namespace, scope, {
+          name: input.name?.trim() || void 0,
+          endpoint: input.endpoint,
+          headers: input.headers,
+          queryParams: input.queryParams,
+          auth: input.auth
+        })
+      };
+    },
+    staticSources: (self) => [
+      {
+        id: "graphql",
+        kind: "control",
+        name: "GraphQL",
+        tools: [
+          {
+            name: "addSource",
+            description: "Add a GraphQL endpoint and register its operations as tools",
+            inputSchema: {
+              type: "object",
+              properties: {
+                endpoint: { type: "string" },
+                name: { type: "string" },
+                introspectionJson: { type: "string" },
+                namespace: { type: "string" },
+                headers: { type: "object" },
+                queryParams: { type: "object" },
+                auth: { type: "object" }
+              },
+              required: ["endpoint"]
+            },
+            outputSchema: {
+              type: "object",
+              properties: {
+                toolCount: { type: "number" }
+              },
+              required: ["toolCount"]
+            },
+            // Static-tool callers don't name a scope. Default to the
+            // outermost scope in the executor's stack — for a single-
+            // scope executor that's the only scope; for a per-user
+            // stack `[user, org]` it writes at `org` so the source is
+            // visible across every user.
+            handler: ({ ctx, args }) => self.addSource({
+              ...args,
+              scope: ctx.scopes.at(-1).id
+            })
+          }
+        ]
+      }
+    ],
+    invokeTool: ({ ctx, toolRow, args }) => Effect7.gen(function* () {
+      const toolScope = toolRow.scope_id;
+      const op = yield* ctx.storage.getOperationByToolId(
+        toolRow.id,
+        toolScope
+      );
+      if (!op) {
+        return yield* Effect7.fail(
+          new Error(`No GraphQL operation found for tool "${toolRow.id}"`)
+        );
+      }
+      const source = yield* ctx.storage.getSource(op.sourceId, toolScope);
+      if (!source) {
+        return yield* Effect7.fail(
+          new Error(`No GraphQL source found for "${op.sourceId}"`)
+        );
+      }
+      const resolvedHeaders = yield* resolveHeaders(
+        source.headers,
+        ctx.secrets
+      );
+      const resolvedQueryParams = yield* resolveHeaders(
+        source.queryParams,
+        ctx.secrets
+      );
+      if (source.auth.kind === "oauth2") {
+        const accessToken = yield* ctx.connections.accessToken(
+          source.auth.connectionId
+        );
+        resolvedHeaders.Authorization = `Bearer ${accessToken}`;
+      }
+      const result = yield* invokeWithLayer(
+        op.binding,
+        args ?? {},
+        source.endpoint,
+        resolvedHeaders,
+        resolvedQueryParams,
+        httpClientLayer
+      );
+      return result;
+    }),
+    resolveAnnotations: ({ ctx, sourceId, toolRows }) => Effect7.gen(function* () {
+      const scopes = /* @__PURE__ */ new Set();
+      for (const row of toolRows) {
+        scopes.add(row.scope_id);
+      }
+      const entries = yield* Effect7.forEach(
+        [...scopes],
+        (scope) => Effect7.gen(function* () {
+          const ops = yield* ctx.storage.listOperationsBySource(
+            sourceId,
+            scope
+          );
+          const byId = /* @__PURE__ */ new Map();
+          for (const op of ops) byId.set(op.toolId, op.binding);
+          return [scope, byId];
+        }),
+        { concurrency: "unbounded" }
+      );
+      const byScope = new Map(entries);
+      const out = {};
+      for (const row of toolRows) {
+        const binding = byScope.get(row.scope_id)?.get(row.id);
+        if (binding) out[row.id] = annotationsFor(binding);
+      }
+      return out;
+    }),
+    removeSource: ({ ctx, sourceId, scope }) => ctx.storage.removeSource(sourceId, scope),
+    detect: ({ url }) => Effect7.gen(function* () {
+      const trimmed = url.trim();
+      if (!trimmed) return null;
+      const parsed = yield* Effect7.try({
+        try: () => new URL(trimmed),
+        catch: (cause) => cause
+      }).pipe(
+        Effect7.option
+      );
+      if (Option3.isNone(parsed)) return null;
+      const ok = yield* introspect(trimmed).pipe(
+        Effect7.provide(httpClientLayer),
+        Effect7.map(() => true),
+        Effect7.catch(() => Effect7.succeed(false))
+      );
+      if (!ok) return null;
+      const name = namespaceFromEndpoint(trimmed);
+      return new SourceDetectionResult({
+        kind: "graphql",
+        confidence: "high",
+        endpoint: trimmed,
+        name,
+        namespace: name
+      });
+    }),
+    routes: () => GraphqlGroup,
+    handlers: () => GraphqlHandlers,
+    extensionService: GraphqlExtensionService
+  };
+});
+
+export {
+  GraphqlIntrospectionError,
+  GraphqlExtractionError,
+  GraphqlInvocationError,
+  GraphqlOperationKind,
+  GraphqlArgument,
+  ExtractedField,
+  ExtractionResult,
+  OperationBinding,
+  HeaderValue,
+  GraphqlSourceAuth,
+  InvocationConfig,
+  InvocationResult,
+  introspect,
+  parseIntrospectionJson,
+  extract,
+  resolveHeaders,
+  invoke,
+  invokeWithLayer,
+  graphqlSchema,
+  makeDefaultGraphqlStore,
+  graphqlPlugin
+};
+//# sourceMappingURL=chunk-EIC5WI6C.js.map