@executor-js/plugin-graphql 0.0.2 → 0.1.0

package/dist/{chunk-ILBZO52O.js → chunk-EIC5WI6C.js}

@@ -17,8 +17,80 @@ var GraphqlExtractionError = class extends Schema.TaggedErrorClass()(
 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 } from "effect";
+import { Effect as Effect2 } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
 var INTROSPECTION_QUERY = `
   query IntrospectionQuery {
@@ -89,7 +161,7 @@ var INTROSPECTION_QUERY = `
     }
   }
 `;
-var introspect = Effect.fn("GraphQL.introspect")(function* (endpoint, headers, queryParams) {
+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);
@@ -110,8 +182,8 @@ var introspect = Effect.fn("GraphQL.introspect")(function* (endpoint, headers, q
     }
   }
   const response = yield* client.execute(request).pipe(
-    Effect.tapCause((cause) => Effect.logError("graphql introspection request failed", cause)),
-    Effect.mapError(
+    Effect2.tapCause((cause) => Effect2.logError("graphql introspection request failed", cause)),
+    Effect2.mapError(
       (err) => new GraphqlIntrospectionError({
         message: `Failed to reach GraphQL endpoint: ${err.message}`
       })
@@ -123,10 +195,10 @@ var introspect = Effect.fn("GraphQL.introspect")(function* (endpoint, headers, q
     });
   }
   const raw = yield* response.json.pipe(
-    Effect.tapCause(
-      (cause) => Effect.logError("graphql introspection JSON parse failed", cause)
+    Effect2.tapCause(
+      (cause) => Effect2.logError("graphql introspection JSON parse failed", cause)
     ),
-    Effect.mapError(
+    Effect2.mapError(
       () => new GraphqlIntrospectionError({
         message: `Failed to parse introspection response as JSON`
       })
@@ -145,7 +217,7 @@ var introspect = Effect.fn("GraphQL.introspect")(function* (endpoint, headers, q
   }
   return json.data;
 });
-var parseIntrospectionJson = (text) => Effect.try({
+var parseIntrospectionJson = (text) => Effect2.try({
   try: () => {
     const parsed = JSON.parse(text);
     const result = parsed.data ?? parsed;
@@ -159,78 +231,6 @@ var parseIntrospectionJson = (text) => Effect.try({
   })
 });
 
-// src/sdk/types.ts
-import { Effect as Effect2, 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(Effect2.succeed({})),
-    Schema2.withConstructorDefault(Effect2.succeed({}))
-  ),
-  /** Query parameters applied to every request. Values can reference secrets. */
-  queryParams: Schema2.Record(Schema2.String, QueryParamValue).pipe(
-    Schema2.withDecodingDefault(Effect2.succeed({})),
-    Schema2.withConstructorDefault(Effect2.succeed({}))
-  )
-}) {
-};
-var InvocationResult = class extends Schema2.Class("InvocationResult")({
-  status: Schema2.Number,
-  data: Schema2.NullOr(Schema2.Unknown),
-  errors: Schema2.NullOr(Schema2.Unknown)
-}) {
-};
-
 // src/sdk/extract.ts
 import { Effect as Effect3, Option } from "effect";
 var unwrapTypeName = (ref) => {
@@ -682,8 +682,139 @@ var makeDefaultGraphqlStore = ({
 };
 
 // src/sdk/plugin.ts
-import { Effect as Effect6, Option as Option3 } from "effect";
+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
@@ -804,18 +935,19 @@ 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) => Effect6.gen(function* () {
+      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) => Effect6.gen(function* () {
+      const resolveOAuthHeader = (auth) => Effect7.gen(function* () {
         if (!auth || auth.kind === "none") return void 0;
         const accessToken = yield* ctx.connections.accessToken(auth.connectionId).pipe(
-          Effect6.mapError(
+          Effect7.mapError(
             (err) => new GraphqlIntrospectionError({
               message: `Failed to resolve OAuth connection "${auth.connectionId}": ${"message" in err ? err.message : String(err)}`
             })
@@ -823,13 +955,13 @@ var graphqlPlugin = definePlugin((options) => {
         );
         return { Authorization: `Bearer ${accessToken}` };
       });
-      const resolveRequestHeaders = (headers, auth) => Effect6.gen(function* () {
+      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(
-        Effect6.gen(function* () {
+        Effect7.gen(function* () {
           let introspectionResult;
           if (config.introspectionJson) {
             introspectionResult = yield* parseIntrospectionJson(
@@ -847,7 +979,7 @@ var graphqlPlugin = definePlugin((options) => {
               config.endpoint,
               Object.keys(resolvedHeaders).length > 0 ? resolvedHeaders : void 0,
               resolvedQueryParams
-            ).pipe(Effect6.provide(httpClientLayer));
+            ).pipe(Effect7.provide(httpClientLayer));
           }
           const { result, definitions } = yield* extract(introspectionResult);
           const namespace = config.namespace ?? namespaceFromEndpoint(config.endpoint);
@@ -899,15 +1031,15 @@ var graphqlPlugin = definePlugin((options) => {
       const configFile = options?.configFile;
       return {
         addSource: (config) => addSourceInternal(config).pipe(
-          Effect6.tap(
+          Effect7.tap(
             (result) => configFile ? configFile.upsertSource(
               toGraphqlConfigEntry(result.namespace, config)
-            ) : Effect6.void
+            ) : Effect7.void
           )
         ),
-        removeSource: (namespace, scope) => Effect6.gen(function* () {
+        removeSource: (namespace, scope) => Effect7.gen(function* () {
           yield* ctx.transaction(
-            Effect6.gen(function* () {
+            Effect7.gen(function* () {
               yield* ctx.storage.removeSource(namespace, scope);
               yield* ctx.core.sources.unregister(namespace);
             })
@@ -968,20 +1100,20 @@ var graphqlPlugin = definePlugin((options) => {
         ]
       }
     ],
-    invokeTool: ({ ctx, toolRow, args }) => Effect6.gen(function* () {
+    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* Effect6.fail(
+        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* Effect6.fail(
+        return yield* Effect7.fail(
           new Error(`No GraphQL source found for "${op.sourceId}"`)
         );
       }
@@ -1009,14 +1141,14 @@ var graphqlPlugin = definePlugin((options) => {
       );
       return result;
     }),
-    resolveAnnotations: ({ ctx, sourceId, toolRows }) => Effect6.gen(function* () {
+    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* Effect6.forEach(
+      const entries = yield* Effect7.forEach(
         [...scopes],
-        (scope) => Effect6.gen(function* () {
+        (scope) => Effect7.gen(function* () {
           const ops = yield* ctx.storage.listOperationsBySource(
             sourceId,
             scope
@@ -1036,20 +1168,20 @@ var graphqlPlugin = definePlugin((options) => {
       return out;
     }),
     removeSource: ({ ctx, sourceId, scope }) => ctx.storage.removeSource(sourceId, scope),
-    detect: ({ url }) => Effect6.gen(function* () {
+    detect: ({ url }) => Effect7.gen(function* () {
       const trimmed = url.trim();
       if (!trimmed) return null;
-      const parsed = yield* Effect6.try({
+      const parsed = yield* Effect7.try({
         try: () => new URL(trimmed),
         catch: (cause) => cause
       }).pipe(
-        Effect6.option
+        Effect7.option
       );
       if (Option3.isNone(parsed)) return null;
       const ok = yield* introspect(trimmed).pipe(
-        Effect6.provide(httpClientLayer),
-        Effect6.map(() => true),
-        Effect6.catch(() => Effect6.succeed(false))
+        Effect7.provide(httpClientLayer),
+        Effect7.map(() => true),
+        Effect7.catch(() => Effect7.succeed(false))
       );
       if (!ok) return null;
       const name = namespaceFromEndpoint(trimmed);
@@ -1060,7 +1192,10 @@ var graphqlPlugin = definePlugin((options) => {
         name,
         namespace: name
       });
-    })
+    }),
+    routes: () => GraphqlGroup,
+    handlers: () => GraphqlHandlers,
+    extensionService: GraphqlExtensionService
   };
 });
 
@@ -1068,8 +1203,6 @@ export {
   GraphqlIntrospectionError,
   GraphqlExtractionError,
   GraphqlInvocationError,
-  introspect,
-  parseIntrospectionJson,
   GraphqlOperationKind,
   GraphqlArgument,
   ExtractedField,
@@ -1079,6 +1212,8 @@ export {
   GraphqlSourceAuth,
   InvocationConfig,
   InvocationResult,
+  introspect,
+  parseIntrospectionJson,
   extract,
   resolveHeaders,
   invoke,
@@ -1087,4 +1222,4 @@ export {
   makeDefaultGraphqlStore,
   graphqlPlugin
 };
-//# sourceMappingURL=chunk-ILBZO52O.js.map
+//# sourceMappingURL=chunk-EIC5WI6C.js.map