@executor-js/plugin-graphql 0.1.0 → 0.2.1

package/dist/chunk-EIC5WI6C.js

@@ -1,1225 +0,0 @@
-// 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