apps 0.0.1-beta.11 → 0.0.1-beta.110

package/js/graphql.js

@@ -1,152 +1,82 @@
 import {
-  catalogCache
-} from "./chunk-RFVIONFX.js";
+  catalogCache,
+  catalogScope
+} from "./chunk-SXQVVXJE.js";
 import {
   protocolOperations
-} from "./chunk-WVVV4TX2.js";
+} from "./chunk-RIV62DRM.js";
 import "./chunk-BCSNKUAC.js";
-import "./chunk-RELFXUOO.js";
+import "./chunk-JCX2K2SI.js";
 import {
   cacheKey
-} from "./chunk-NKLWZJLE.js";
-import "./chunk-Z2QY3YTF.js";
-import "./chunk-IPI4MFSN.js";
-import "./chunk-TYVDBQSI.js";
-import "./chunk-ZQINWV4W.js";
+} from "./chunk-UPTAFF6L.js";
+import {
+  GraphqlError,
+  GraphqlIntrospection,
+  GraphqlResponse,
+  GraphqlToolDefinition,
+  GraphqlToolsOptions,
+  defaultGraphqlClientLimits,
+  maxGraphqlStatedErrors,
+  maxGraphqlStatedExtensions,
+  maxGraphqlStatedFieldLength
+} from "./chunk-BKIQCV72.js";
+import {
+  failOnNetworkRefusal
+} from "./chunk-HLMJBE4T.js";
+import "./chunk-PBGPES67.js";
+import "./chunk-3BI34I5S.js";
 import {
   nativeOperation,
   routerDeclaration
-} from "./chunk-GPFVWWDZ.js";
+} from "./chunk-ZXG7RMCB.js";
 import {
   accountProviderError,
+  boundStated,
   graphqlProviderError,
   httpProviderError
-} from "./chunk-MKWZPDR6.js";
-import "./chunk-KRSCJDTW.js";
-import "./chunk-N7YDVXYJ.js";
+} from "./chunk-OIH73VFM.js";
 import {
-  ProviderError
-} from "./chunk-R3EV5FTO.js";
-import "./chunk-JU7VHODU.js";
-import "./chunk-ODEIDRGW.js";
+  FailureFieldName,
+  NetworkRefused,
+  ProviderError,
+  defaultOpenapiErrorLimits,
+  maxUpstreamMessageLength
+} from "./chunk-2RGJMA7N.js";
+import "./chunk-4PIQKACY.js";
 import {
-  FetchHttpClient_exports
-} from "./chunk-57RKNWL2.js";
+  jsonSchemaDecoder
+} from "./chunk-VAI3EVCS.js";
 import {
-  HttpClientRequest_exports,
-  HttpClient_exports
-} from "./chunk-UK573G7W.js";
+  owned
+} from "./chunk-URKOTNDA.js";
 import {
-  jsonSchemaDecoder
-} from "./chunk-5T57N25Q.js";
-import "./chunk-PZB6T6KU.js";
+  FetchHttpClient_exports
+} from "./chunk-YDW7DX3A.js";
+import "./chunk-OWN3DP2W.js";
 import {
-  AccountId,
-  HttpUrl,
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-7HG422GB.js";
+import "./chunk-DILSCQPJ.js";
+import {
+  HttpClientRequest_exports,
+  HttpClient_exports
+} from "./chunk-ACQXVKVQ.js";
 import {
   Effect_exports,
+  Option_exports,
   Redacted_exports,
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+  Ref_exports,
+  Result_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-ZKDXML77.js";
 import "./chunk-CZ7CSFO4.js";
 
-// src/contracts/graphql.ts
-var GraphqlClientLimits = Schema_exports.Struct({
-  timeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  maxTimeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultGraphqlClientLimits = GraphqlClientLimits.make({
-  timeoutMs: 3e4,
-  maxTimeoutMs: 3e5
-});
-var GraphqlToolsOptions = Schema_exports.Struct({
-  url: HttpUrl,
-  accountId: Schema_exports.optional(AccountId),
-  headers: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
-  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
-  timeoutMs: Schema_exports.optional(
-    Schema_exports.Int.check(
-      Schema_exports.isBetween({ minimum: 1, maximum: defaultGraphqlClientLimits.maxTimeoutMs })
-    )
-  )
-});
-var GraphqlError = class extends Schema_exports.TaggedError()("GraphqlError", {
-  phase: Schema_exports.Literals(["discover", "call"]),
-  reason: Schema_exports.Literals([
-    "request",
-    "unauthorized",
-    "invalid_response",
-    "invalid_input",
-    "timeout",
-    "execution"
-  ]),
-  status: Schema_exports.optional(Schema_exports.Number)
-}) {
-};
-var Name = Schema_exports.String.check(Schema_exports.isPattern(/^[_A-Za-z][_0-9A-Za-z]*$/));
-var Kind = Schema_exports.Literals([
-  "SCALAR",
-  "OBJECT",
-  "INTERFACE",
-  "UNION",
-  "ENUM",
-  "INPUT_OBJECT",
-  "LIST",
-  "NON_NULL"
-]);
-var GraphqlTypeRef = Schema_exports.Struct({
-  kind: Kind,
-  name: Schema_exports.NullOr(Name),
-  ofType: Schema_exports.optional(Schema_exports.NullOr(Schema_exports.suspend(() => GraphqlTypeRef)))
-});
-var Argument = Schema_exports.Struct({
-  name: Name,
-  description: Schema_exports.NullOr(Schema_exports.String),
-  type: GraphqlTypeRef,
-  defaultValue: Schema_exports.NullOr(Schema_exports.String)
-});
-var GraphqlField = Schema_exports.Struct({
-  name: Name,
-  description: Schema_exports.NullOr(Schema_exports.String),
-  args: Schema_exports.Array(Argument),
-  type: GraphqlTypeRef
-});
-var GraphqlIntrospection = Schema_exports.Struct({
-  __schema: Schema_exports.Struct({
-    queryType: Schema_exports.NullOr(Schema_exports.Struct({ name: Name })),
-    mutationType: Schema_exports.NullOr(Schema_exports.Struct({ name: Name })),
-    types: Schema_exports.Array(
-      Schema_exports.Struct({
-        kind: Kind,
-        name: Name,
-        fields: Schema_exports.NullOr(Schema_exports.Array(GraphqlField)),
-        inputFields: Schema_exports.NullOr(Schema_exports.Array(Argument)),
-        enumValues: Schema_exports.NullOr(Schema_exports.Array(Schema_exports.Struct({ name: Name })))
-      })
-    )
-  })
-});
-var GraphqlResponse = Schema_exports.Struct({
-  data: Schema_exports.optional(Schema_exports.NullOr(JsonObject)),
-  errors: Schema_exports.optional(Schema_exports.Array(JsonObject))
-});
-var GraphqlToolDefinition = Schema_exports.Struct({
-  name: Name,
-  kind: Schema_exports.Literals(["query", "mutation"]),
-  field: Name,
-  description: Schema_exports.String,
-  arguments: Schema_exports.Array(Schema_exports.Struct({ name: Name, type: Schema_exports.String })),
-  inputSchema: JsonObject,
-  composite: Schema_exports.Boolean,
-  selection: Schema_exports.String
-});
-
 // src/implementation/graphql.ts
 import {
   getIntrospectionQuery,
-  Kind as Kind2,
+  Kind,
   OperationTypeNode,
   parse,
   parseType,
@@ -238,14 +168,91 @@ function fieldInput(field, types) {
     }
   };
 }
+var ResponseError = Schema_exports.Struct({
+  message: Schema_exports.String,
+  path: Schema_exports.optional(Schema_exports.Array(Schema_exports.Union([Schema_exports.String, Schema_exports.Int]))),
+  extensions: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown))
+});
+var boundedPath = (path) => {
+  const segments = [];
+  let length = 0;
+  for (const segment of path) {
+    if (length > maxGraphqlStatedFieldLength) break;
+    const bounded = typeof segment === "number" ? segment : boundStated(segment, maxGraphqlStatedFieldLength);
+    length += typeof bounded === "number" ? String(bounded).length + 2 : Math.max(bounded.length, 1) + (segments.length === 0 ? 0 : 1);
+    segments.push(bounded);
+  }
+  return segments;
+};
+var extensionEntries = (extensions) => {
+  const entries = {};
+  let count = 0;
+  for (const key of [
+    ...Object.hasOwn(extensions, "code") ? ["code"] : [],
+    ...Object.keys(extensions).filter((key2) => key2 !== "code")
+  ]) {
+    if (count === maxGraphqlStatedExtensions) break;
+    const value = extensions[key];
+    if (!Schema_exports.is(FailureFieldName)(key)) continue;
+    if (typeof value === "string") entries[key] = boundStated(value, maxGraphqlStatedFieldLength);
+    else if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      entries[key] = value;
+    else continue;
+    count++;
+  }
+  return count === 0 ? void 0 : entries;
+};
+var statedErrors = (errors) => {
+  const stated = errors.slice(0, maxGraphqlStatedErrors).flatMap((error) => Option_exports.toArray(Schema_exports.decodeUnknownOption(ResponseError)(error))).map(({ message, path, extensions }) => {
+    const entries = extensions === void 0 ? void 0 : extensionEntries(extensions);
+    return {
+      message: boundStated(message, maxUpstreamMessageLength),
+      ...path === void 0 || path.length === 0 ? {} : { path: boundedPath(path) },
+      ...entries === void 0 ? {} : { extensions: entries }
+    };
+  });
+  return {
+    ...stated.length === 0 ? {} : { errors: stated },
+    ...errors.length > stated.length ? { stated: errors.length } : {}
+  };
+};
+var RefusedBody = Schema_exports.fromJsonString(
+  Schema_exports.Struct({ errors: Schema_exports.optional(Schema_exports.Array(Schema_exports.Unknown)) })
+);
+var refusedBody = (response) => Effect_exports.gen(function* () {
+  if (!/^application\/(?:[\w.-]+\+)?json$/i.test(
+    response.headers["content-type"]?.split(";")[0]?.trim() ?? ""
+  ))
+    return {};
+  const length = response.headers["content-length"];
+  if (length !== void 0 && Number(length) > defaultOpenapiErrorLimits.maxBodyBytes)
+    return { unreadBody: "too_large" };
+  const text = yield* response.stream.pipe(
+    Stream_exports.mapError(() => "incomplete"),
+    Stream_exports.limitBytes(
+      defaultOpenapiErrorLimits.maxBodyBytes,
+      () => Stream_exports.fail("too_large")
+    ),
+    Stream_exports.decodeText,
+    Stream_exports.mkString,
+    Effect_exports.timeoutOrElse({
+      duration: defaultOpenapiErrorLimits.readTimeoutMs,
+      orElse: () => Effect_exports.fail("incomplete")
+    }),
+    Effect_exports.result
+  );
+  if (Result_exports.isFailure(text)) return { unreadBody: text.failure };
+  const body = Schema_exports.decodeUnknownOption(RefusedBody)(text.success);
+  return Option_exports.isSome(body) && body.value.errors?.length ? statedErrors(body.value.errors) : {};
+});
 function selection(text) {
   const document = parse("query { result { " + text + " } }");
   const definition = document.definitions[0];
-  if (document.definitions.length !== 1 || definition?.kind !== Kind2.OPERATION_DEFINITION || definition.selectionSet.selections.length !== 1) {
+  if (document.definitions.length !== 1 || definition?.kind !== Kind.OPERATION_DEFINITION || definition.selectionSet.selections.length !== 1) {
     throw new GraphqlError({ phase: "call", reason: "invalid_input" });
   }
   const field = definition.selectionSet.selections[0];
-  if (field?.kind !== Kind2.FIELD || field.name.value !== "result" || !field.selectionSet)
+  if (field?.kind !== Kind.FIELD || field.name.value !== "result" || !field.selectionSet)
     throw new GraphqlError({ phase: "call", reason: "invalid_input" });
   return field.selectionSet;
 }
@@ -257,52 +264,83 @@ var graphqlClientEffect = (input) => Effect_exports.gen(function* () {
   if (url.username || url.password || url.hash)
     return yield* new GraphqlError({ phase: "discover", reason: "invalid_input" });
   const headers = Redacted_exports.make({ ...options.headers });
-  const request = (phase, query, variables = {}) => Effect_exports.scoped(
-    Effect_exports.gen(function* () {
-      const client = yield* HttpClient_exports.HttpClient;
-      const response = yield* HttpClient_exports.withScope(client).execute(
-        HttpClientRequest_exports.post(url.href).pipe(
-          // GitHub requires this header; Workers do not supply one by default.
-          HttpClientRequest_exports.setHeader("user-agent", "Executor"),
-          HttpClientRequest_exports.setHeaders(Redacted_exports.value(headers)),
-          HttpClientRequest_exports.bodyJsonUnsafe({ query, variables })
+  const request = (phase, query, variables = {}) => Effect_exports.gen(function* () {
+    const refusal = yield* Ref_exports.make(Option_exports.none());
+    return yield* Effect_exports.scoped(
+      Effect_exports.gen(function* () {
+        const client = yield* HttpClient_exports.HttpClient;
+        const response = yield* HttpClient_exports.withScope(client).execute(
+          HttpClientRequest_exports.post(url.href).pipe(
+            // GitHub requires this header; Workers do not supply one by default.
+            HttpClientRequest_exports.setHeader("user-agent", "Executor"),
+            HttpClientRequest_exports.setHeaders(Redacted_exports.value(headers)),
+            HttpClientRequest_exports.bodyJsonUnsafe({ query, variables })
+          )
+        );
+        yield* failOnNetworkRefusal(response);
+        if (response.status < 200 || response.status >= 300) {
+          const classified = httpProviderError(response.status, response.headers);
+          if (classified !== void 0) return yield* classified;
+          yield* Ref_exports.set(refusal, Option_exports.some(response.status));
+          const refused = yield* refusedBody(response).pipe(
+            owned("upstream", "provider.http.response.read")
+          );
+          return yield* new GraphqlError({
+            phase,
+            reason: "request",
+            status: response.status,
+            ...refused
+          });
+        }
+        const result = yield* response.json.pipe(
+          owned("upstream", "provider.http.response.read"),
+          Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlResponse)),
+          Effect_exports.mapError(() => new GraphqlError({ phase, reason: "invalid_response" }))
+        );
+        if (result.errors?.length)
+          return yield* graphqlProviderError(result.errors, response.status) ?? new GraphqlError({
+            phase,
+            reason: "execution",
+            status: response.status,
+            ...statedErrors(result.errors)
+          });
+        if (result.data == null)
+          return yield* new GraphqlError({ phase, reason: "invalid_response" });
+        return result.data;
+      })
+    ).pipe(
+      owned("upstream", "provider.graphql.request", {
+        attributes: {
+          "executor.operation": phase,
+          "server.address": url.hostname
+        }
+      }),
+      Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+      Effect_exports.provideService(FetchHttpClient_exports.Fetch, globalThis.fetch),
+      Effect_exports.provide(FetchHttpClient_exports.layer),
+      Effect_exports.timeoutOrElse({
+        duration: options.timeoutMs ?? defaultGraphqlClientLimits.timeoutMs,
+        orElse: () => Effect_exports.flatMap(
+          Ref_exports.get(refusal),
+          (status) => Effect_exports.fail(
+            Option_exports.isSome(status) ? new GraphqlError({
+              phase,
+              reason: "request",
+              status: status.value,
+              unreadBody: "incomplete"
+            }) : new GraphqlError({ phase, reason: "timeout" })
+          )
         )
-      );
-      if (response.status < 200 || response.status >= 300)
-        return yield* httpProviderError(response.status, response.headers) ?? new GraphqlError({ phase, reason: "request", status: response.status });
-      const result = yield* response.json.pipe(
-        Effect_exports.withSpan("provider.http.response.read"),
-        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlResponse)),
-        Effect_exports.mapError(() => new GraphqlError({ phase, reason: "invalid_response" }))
-      );
-      if (result.errors?.length)
-        return yield* graphqlProviderError(result.errors, response.status) ?? new GraphqlError({ phase, reason: "execution", status: response.status });
-      if (result.data == null)
-        return yield* new GraphqlError({ phase, reason: "invalid_response" });
-      return result.data;
-    })
-  ).pipe(
-    Effect_exports.withSpan("provider.graphql.request", {
-      attributes: {
-        "executor.operation": phase,
-        "server.address": url.hostname
-      }
-    }),
-    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
-    Effect_exports.provideService(FetchHttpClient_exports.Fetch, globalThis.fetch),
-    Effect_exports.provide(FetchHttpClient_exports.layer),
-    Effect_exports.timeoutOrElse({
-      duration: options.timeoutMs ?? defaultGraphqlClientLimits.timeoutMs,
-      orElse: () => Effect_exports.fail(new GraphqlError({ phase, reason: "timeout" }))
-    }),
-    Effect_exports.mapError(
-      (error) => error instanceof ProviderError && options.accountId !== void 0 ? accountProviderError(error, options.accountId) : error instanceof GraphqlError || error instanceof ProviderError ? error : new GraphqlError({ phase, reason: "request" })
-    )
-  );
+      }),
+      Effect_exports.mapError(
+        (error) => error instanceof ProviderError && options.accountId !== void 0 ? accountProviderError(error, options.accountId) : error instanceof GraphqlError || error instanceof ProviderError || error instanceof NetworkRefused ? error : new GraphqlError({ phase, reason: "request" })
+      )
+    );
+  });
   const discover = request("discover", getIntrospectionQuery()).pipe(
     Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlIntrospection)),
     Effect_exports.mapError(
-      (error) => error instanceof GraphqlError || error instanceof ProviderError ? error : new GraphqlError({ phase: "discover", reason: "invalid_response" })
+      (error) => error instanceof GraphqlError || error instanceof ProviderError || error instanceof NetworkRefused ? error : new GraphqlError({ phase: "discover", reason: "invalid_response" })
     )
   );
   return { request, discover };
@@ -364,31 +402,31 @@ var adaptGraphqlTool = (client, definition) => Effect_exports.gen(function* () {
         try: () => {
           const used = definition.arguments.filter((arg) => Object.hasOwn(variables, arg.name));
           return print({
-            kind: Kind2.DOCUMENT,
+            kind: Kind.DOCUMENT,
             definitions: [
               {
-                kind: Kind2.OPERATION_DEFINITION,
+                kind: Kind.OPERATION_DEFINITION,
                 operation: kind,
                 variableDefinitions: used.map((arg) => ({
-                  kind: Kind2.VARIABLE_DEFINITION,
+                  kind: Kind.VARIABLE_DEFINITION,
                   variable: {
-                    kind: Kind2.VARIABLE,
-                    name: { kind: Kind2.NAME, value: arg.name }
+                    kind: Kind.VARIABLE,
+                    name: { kind: Kind.NAME, value: arg.name }
                   },
                   type: parseType(arg.type)
                 })),
                 selectionSet: {
-                  kind: Kind2.SELECTION_SET,
+                  kind: Kind.SELECTION_SET,
                   selections: [
                     {
-                      kind: Kind2.FIELD,
-                      name: { kind: Kind2.NAME, value: definition.field },
+                      kind: Kind.FIELD,
+                      name: { kind: Kind.NAME, value: definition.field },
                       arguments: used.map((arg) => ({
-                        kind: Kind2.ARGUMENT,
-                        name: { kind: Kind2.NAME, value: arg.name },
+                        kind: Kind.ARGUMENT,
+                        name: { kind: Kind.NAME, value: arg.name },
                         value: {
-                          kind: Kind2.VARIABLE,
-                          name: { kind: Kind2.NAME, value: arg.name }
+                          kind: Kind.VARIABLE,
+                          name: { kind: Kind.NAME, value: arg.name }
                         }
                       })),
                       ...definition.composite ? {
@@ -411,7 +449,7 @@ var adaptGraphqlTool = (client, definition) => Effect_exports.gen(function* () {
         return yield* new GraphqlError({ phase: "call", reason: "invalid_response" });
       return value;
     }).pipe(
-      Effect_exports.withSpan("provider.graphql.call", {
+      owned("upstream", "provider.graphql.call", {
         attributes: {
           "graphql.operation.type": kind,
           "executor.tool.name": name
@@ -429,17 +467,20 @@ var GraphqlToolSummary = GraphqlToolDefinition.mapFields(({ name, kind, descript
   description
 }));
 var graphqlCatalog = (options, kinds) => Effect_exports.gen(function* () {
-  const parsed = yield* Schema_exports.decodeUnknownEffect(GraphqlToolsOptions)(options).pipe(
-    Effect_exports.mapError(() => new GraphqlError({ phase: "discover", reason: "invalid_input" }))
-  );
-  const headers = {};
-  new Headers(parsed.headers).forEach((value, name) => {
-    headers[name] = value;
-  });
-  const id = yield* cacheKey({ url: parsed.url, headers, accountId: parsed.accountId ?? null });
+  const invalid = () => new GraphqlError({ phase: "discover", reason: "invalid_input" });
+  const parsed = yield* Schema_exports.decodeUnknownEffect(GraphqlToolsOptions)({
+    url: options.url,
+    accountId: options.account?.id,
+    headers: options.headers,
+    signal: options.signal,
+    timeoutMs: options.timeoutMs
+  }).pipe(Effect_exports.mapError(invalid));
+  const cache = yield* catalogScope(options, options.headers, invalid);
+  const id = yield* cacheKey({ url: parsed.url });
   const client = yield* graphqlClientEffect(parsed);
   const catalog = yield* catalogCache({
     ...options,
+    cache,
     prefix: ["graphql-catalog-v2", id],
     schema: GraphqlToolDefinition,
     summary: {
@@ -456,7 +497,9 @@ var graphqlCatalog = (options, kinds) => Effect_exports.gen(function* () {
   const summarize = (tool) => ({
     name: tool.name,
     description: tool.description,
-    readOnly: kindOf(tool) === "query"
+    readOnly: kindOf(tool) === "query",
+    // The app's `kinds`, or the GraphQL operation type Executor sends.
+    kindConfirmed: true
   });
   const describe = (tool) => ({
     ...summarize(tool),