// ---------------------------------------------------------------------------// The exact URL introspection dials.//// Keeping a query-carried credential out of the log means splitting the query// off `request.url` and into `request.urlParams` (see// `introspect-credential-logging.test.ts`). The client recombines the two by// appending each pair through `URLSearchParams`, so the query is re-serialized// in form-urlencoded form rather than passed through byte-for-byte.//// That is a real, if narrow, wire change, and it is not recoverable: raw query// bytes only survive inside `request.url`, which is the single field every// `HttpClientError` message renders. So the normalization is pinned here by// exact string equality rather than described in prose — a `toContain` check// would let any of these encodings drift silently, and an upstream that signs// its query string would notice.// --------------------------------------------------------------------------- import { describe, expect, it } from "@effect/vitest";import { Cause, Effect, Layer, Logger } from "effect";import { FetchHttpClient } from "effect/unstable/http"; import { GraphqlIntrospectionError } from "./errors";import { introspect } from "./introspect"; const ENDPOINT = "https://graph.example.test/graphql"; /** Records the URL handed to the platform, then fails the transport so the *  effect finishes without a live host. */const recordingFetch = (seen: Array<string>): typeof globalThis.fetch =>  (async (input: RequestInfo | URL) => {    seen.push(input instanceof Request ? input.url : String(input));    // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: simulates the platform fetch rejecting on a dead host    throw new Error("getaddrinfo ENOTFOUND graph.example.test");  }) as typeof globalThis.fetch; const clientLayer = (seen: Array<string>) =>  FetchHttpClient.layer.pipe(    Layer.provide(Layer.succeed(FetchHttpClient.Fetch)(recordingFetch(seen))),  ); const silentLogger = Logger.layer([Logger.make<unknown, void>(() => {})]); /** Runs introspection against a fetch that always fails, and returns the one *  URL it was asked to dial. */const dialedUrl = (endpoint: string, queryParams?: Record<string, string>) =>  Effect.gen(function* () {    const seen: Array<string> = [];    yield* introspect(endpoint, undefined, queryParams).pipe(      Effect.flip,      Effect.provide(clientLayer(seen)),      Effect.provide(silentLogger),    );    expect(seen).toHaveLength(1);    return seen[0];  }); describe("GraphQL introspection request URL", () => {  it.effect("merges query params into an endpoint that already has some", () =>    Effect.gen(function* () {      // Endpoint params keep their position and order; merged params are      // appended after them.      const url = yield* dialedUrl(`${ENDPOINT}?apiVersion=2&region=eu`, {        token: "s3cr3t",        trace: "on",      });      expect(url).toBe(`${ENDPOINT}?apiVersion=2&region=eu&token=s3cr3t&trace=on`);    }),  );   it.effect("adds a query to an endpoint that has none", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(ENDPOINT, { token: "s3cr3t" });      expect(url).toBe(`${ENDPOINT}?token=s3cr3t`);    }),  );   it.effect("overwrites a duplicate param in place rather than appending it", () =>    Effect.gen(function* () {      // The supplied param wins, and it keeps the endpoint param's position —      // so the stale value is gone, not merely shadowed.      const url = yield* dialedUrl(`${ENDPOINT}?token=stale&keep=1`, { token: "fresh" });      expect(url).toBe(`${ENDPOINT}?token=fresh&keep=1`);    }),  );   it.effect("collapses repeats of an overwritten key to the supplied value", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(`${ENDPOINT}?a=1&a=2`, { a: "3" });      expect(url).toBe(`${ENDPOINT}?a=3`);    }),  );   it.effect("keeps repeated keys the caller did not overwrite", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(`${ENDPOINT}?a=1&a=2&b=3`);      expect(url).toBe(`${ENDPOINT}?a=1&a=2&b=3`);    }),  );   it.effect("re-encodes a %20 space as +", () =>    Effect.gen(function* () {      // Documented normalization, not an accident: `URLSearchParams` serializes      // a space in form-urlencoded form. The decoded value is unchanged.      const url = yield* dialedUrl(`${ENDPOINT}?token=a%20b`);      expect(url).toBe(`${ENDPOINT}?token=a+b`);    }),  );   it.effect("leaves a + space as +", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(`${ENDPOINT}?token=a+b`);      expect(url).toBe(`${ENDPOINT}?token=a+b`);    }),  );   it.effect("percent-encodes a literal tilde", () =>    Effect.gen(function* () {      // `~` is legal in a raw query and is left alone by `URL`, but the      // form-urlencoded serializer escapes it.      const url = yield* dialedUrl(`${ENDPOINT}?sig=~tilde~`);      expect(url).toBe(`${ENDPOINT}?sig=%7Etilde%7E`);    }),  );   it.effect("gives a valueless flag a trailing =", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(`${ENDPOINT}?debug`);      expect(url).toBe(`${ENDPOINT}?debug=`);    }),  );   it.effect("leaves an already-encoded reserved character encoded", () =>    Effect.gen(function* () {      const url = yield* dialedUrl(`${ENDPOINT}?a=%2B`);      expect(url).toBe(`${ENDPOINT}?a=%2B`);    }),  );   it.effect("rejects an endpoint carrying userinfo, without echoing it", () =>    Effect.gen(function* () {      // `user:pass@host` is a credential placement that `URL` keeps in the      // origin, so it would ride along in `request.url` and render into every      // `HttpClientError` message — the exact leak the query split closes.      const seen: Array<string> = [];      const logged: Array<string> = [];       const error = yield* introspect("https://svc:hunter2@graph.example.test/graphql").pipe(        Effect.flip,        Effect.provide(clientLayer(seen)),        Effect.provide(          Logger.layer([            Logger.make<unknown, void>((options) => {              logged.push(String(options.message));              logged.push(Cause.pretty(options.cause));            }),          ]),        ),      );       expect(error).toBeInstanceOf(GraphqlIntrospectionError);      expect(error.reason).toBe("invalid-endpoint");       // Nothing was dialed, and neither the error nor the log names the secret.      expect(seen).toHaveLength(0);      const rendered = `${Cause.pretty(Cause.fail(error))}\n${logged.join("\n")}`;      expect(rendered).not.toContain("hunter2");      expect(rendered).not.toContain("svc:");    }),  );   it.effect("rejects userinfo even when only a username is present", () =>    Effect.gen(function* () {      const seen: Array<string> = [];      const error = yield* introspect("https://svc@graph.example.test/graphql", undefined, {        token: "s3cr3t",      }).pipe(Effect.flip, Effect.provide(clientLayer(seen)), Effect.provide(silentLogger));       expect(error.reason).toBe("invalid-endpoint");      expect(seen).toHaveLength(0);    }),  );});