@rafads/plugin-openapi 1.5.38

package/dist/testing/index.d.ts

@@ -0,0 +1,177 @@
+import { Context, Effect, Layer, Scope } from "effect";
+import { HttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpApi } from "effect/unstable/httpapi";
+import { OAuthTestServer } from "@rafads/sdk/testing";
+import { IntegrationSlug, type Connection, type CreateConnectionInput, type Owner, type ToolAddress as ToolAddressType } from "@rafads/sdk/core";
+import type { OpenApiPluginExtension, OpenApiSpecConfig } from "../sdk/plugin";
+declare const OpenApiTestServerAddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiTestServerAddressError";
+} & Readonly<A>;
+export declare class OpenApiTestServerAddressError extends OpenApiTestServerAddressError_base<{
+    readonly address: unknown;
+}> {
+}
+declare const OpenApiTestServerSpecError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiTestServerSpecError";
+} & Readonly<A>;
+export declare class OpenApiTestServerSpecError extends OpenApiTestServerSpecError_base<{
+    readonly cause: unknown;
+}> {
+}
+export interface OpenApiTestServerShape {
+    readonly baseUrl: string;
+    readonly specJson: string;
+    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
+}
+export interface OpenApiHttpApiTestServerOptions {
+    readonly api: HttpApi.Any;
+    readonly handlersLayer: Layer.Layer<any, any, any>;
+    readonly specPath?: `/${string}`;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+    readonly captureSpecRequest?: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<void>;
+    readonly guardSpecRequest?: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse | null>;
+}
+export interface OpenApiHttpApiTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+}
+export interface MutableOpenApiSpecTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+    readonly setApi: (api: HttpApi.Any) => Effect.Effect<void, OpenApiTestServerSpecError>;
+    readonly requestCount: Effect.Effect<number>;
+}
+export interface OpenApiTestRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+export interface OpenApiEchoTestServerOptions {
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+    readonly oauth2?: {
+        readonly authorizationUrl: string;
+        readonly tokenUrl: string;
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly validateAuthorization?: (authorization: string | null) => Effect.Effect<boolean>;
+        readonly wwwAuthenticate?: string;
+    };
+}
+export interface OpenApiEchoTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+    readonly requests: Effect.Effect<readonly OpenApiTestRequest[]>;
+    readonly clearRequests: Effect.Effect<void>;
+}
+export type OpenApiTestIntegrationOptions = Omit<OpenApiSpecConfig, "spec" | "baseUrl" | "slug"> & {
+    readonly baseUrl?: string | null;
+    readonly slug?: string;
+};
+export type OpenApiHttpApiTestIntegrationOptions = Omit<OpenApiSpecConfig, "spec" | "slug" | "baseUrl"> & {
+    readonly slug?: string;
+    readonly baseUrl?: string | null;
+    readonly specBaseUrl?: string;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+};
+type OpenApiHttpApiAddSpecHeadersInput = {
+    readonly headers?: Record<string, string>;
+    readonly queryParams?: Record<string, string>;
+};
+export type OpenApiHttpApiTestAddSpecPayloadOptions = Omit<OpenApiHttpApiTestIntegrationOptions, "headers" | "queryParams"> & OpenApiHttpApiAddSpecHeadersInput;
+export type OpenApiTestIntegrationExecutor = {
+    readonly openapi: Pick<OpenApiPluginExtension, "addSpec">;
+};
+export type OpenApiTestConnectionExecutor = {
+    readonly openapi: Pick<OpenApiPluginExtension, "addSpec">;
+    readonly connections: {
+        readonly create: (input: CreateConnectionInput) => Effect.Effect<Connection, unknown>;
+    };
+};
+export interface OpenApiTestConnectionOptions {
+    readonly slug?: string;
+    readonly owner?: Owner;
+    readonly connection?: string;
+    readonly template?: string;
+    /** Inline credential value. Defaults to a throwaway token via the in-memory
+     *  provider's `from` path is avoided — pass `value` to store a real secret. */
+    readonly value?: string;
+    readonly baseUrl?: string | null;
+}
+export interface OpenApiTestConnection {
+    readonly slug: string;
+    readonly owner: Owner;
+    readonly connection: string;
+    readonly address: (tool: string) => ToolAddressType;
+}
+/** addSpec + connections.create from a raw server spec; returns an address
+ *  builder for `executor.execute`. */
+export declare const addOpenApiTestConnection: (executor: OpenApiTestConnectionExecutor, server: OpenApiTestServerShape, integrationOptions: OpenApiTestIntegrationOptions, connectionOptions?: OpenApiTestConnectionOptions) => Effect.Effect<OpenApiTestConnection, unknown>;
+export interface OpenApiTestSpecOptions {
+    readonly baseUrl?: string;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+}
+export declare const makeOpenApiTestSpecJson: (api: HttpApi.Any, options?: OpenApiTestSpecOptions) => string;
+export declare const makeOpenApiTestIntegrationConfig: (server: OpenApiTestServerShape, options: OpenApiTestIntegrationOptions) => OpenApiSpecConfig;
+export declare const addOpenApiTestIntegration: (executor: OpenApiTestIntegrationExecutor, server: OpenApiTestServerShape, options: OpenApiTestIntegrationOptions) => Effect.Effect<{
+    readonly slug: IntegrationSlug;
+    readonly toolCount: number;
+}, import("@rafads/sdk/core").StorageFailure | import("@rafads/sdk/core").IntegrationAlreadyExistsError | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError, never>;
+export declare const makeOpenApiHttpApiTestIntegrationConfig: (api: HttpApi.Any, options: OpenApiHttpApiTestIntegrationOptions) => OpenApiSpecConfig;
+export declare const addOpenApiHttpApiTestIntegration: (executor: OpenApiTestIntegrationExecutor, api: HttpApi.Any, options: OpenApiHttpApiTestIntegrationOptions) => Effect.Effect<{
+    readonly slug: IntegrationSlug;
+    readonly toolCount: number;
+}, import("@rafads/sdk/core").StorageFailure | import("@rafads/sdk/core").IntegrationAlreadyExistsError | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError, never>;
+export declare const makeOpenApiHttpApiTestAddSpecPayload: (api: HttpApi.Any, options: OpenApiHttpApiTestAddSpecPayloadOptions) => {
+    authenticationTemplate?: readonly import("../sdk").AuthenticationInput[] | undefined;
+    queryParams?: Record<string, string> | undefined;
+    headers?: Record<string, string> | undefined;
+    spec: {
+        readonly kind: "url";
+        readonly url: string;
+    } | {
+        readonly value: string;
+        readonly kind: "blob";
+    };
+    slug: string | undefined;
+    baseUrl: string | undefined;
+};
+export declare const makeOpenApiHttpApiTestSpecPayload: (api: HttpApi.Any, options?: OpenApiTestSpecOptions) => {
+    spec: string;
+};
+export declare const serveOpenApiHttpApiTestServer: (options: OpenApiHttpApiTestServerOptions) => Effect.Effect<OpenApiHttpApiTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+declare const OpenApiHttpApiTestServer_base: Context.ServiceClass<OpenApiHttpApiTestServer, "@rafads/plugin-openapi/testing/OpenApiHttpApiTestServer", OpenApiHttpApiTestServerShape>;
+export declare class OpenApiHttpApiTestServer extends OpenApiHttpApiTestServer_base {
+    static readonly layer: (options: OpenApiHttpApiTestServerOptions) => Layer.Layer<OpenApiHttpApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+}
+export declare const serveMutableOpenApiSpecTestServer: (options: {
+    readonly initialApi: HttpApi.Any;
+    readonly specPath?: `/${string}`;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+}) => Effect.Effect<MutableOpenApiSpecTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+export declare const serveOpenApiEchoTestServer: (options?: OpenApiEchoTestServerOptions) => Effect.Effect<OpenApiEchoTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+export declare const serveOpenApiEchoTestServerWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+    readonly scopes?: Readonly<Record<string, string>>;
+    readonly wwwAuthenticate?: string;
+}) => Effect.Effect<OpenApiEchoTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope | OAuthTestServer>;
+declare const OpenApiEchoTestServer_base: Context.ServiceClass<OpenApiEchoTestServer, "@rafads/plugin-openapi/testing/OpenApiEchoTestServer", OpenApiEchoTestServerShape>;
+export declare class OpenApiEchoTestServer extends OpenApiEchoTestServer_base {
+    static readonly layer: (options?: OpenApiEchoTestServerOptions) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    static readonly layerWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly wwwAuthenticate?: string;
+    }) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, OAuthTestServer>;
+}
+export declare const TestLayers: {
+    httpApi: (options: OpenApiHttpApiTestServerOptions) => Layer.Layer<OpenApiHttpApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    echo: (options?: OpenApiEchoTestServerOptions) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    echoWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly wwwAuthenticate?: string;
+    }) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, OAuthTestServer>;
+};
+export interface OpenApiInvocationResult<TData = Record<string, unknown> | unknown[] | null> {
+    readonly status: number | null;
+    readonly headers: Record<string, string> | null;
+    readonly data: TData;
+    readonly error: unknown;
+}
+export declare const unwrapInvocation: <TData = Record<string, unknown> | null>(raw: unknown) => OpenApiInvocationResult<TData>;
+export {};

package/dist/testing.js

@@ -0,0 +1,454 @@
+// src/testing/index.ts
+import { Context, Data, Effect, Layer, Predicate, Ref, Schema } from "effect";
+import {
+  HttpRouter,
+  HttpServerRequest,
+  HttpServerResponse
+} from "effect/unstable/http";
+import {
+  HttpApi,
+  HttpApiBuilder,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  OpenApi
+} from "effect/unstable/httpapi";
+import { OAuthTestServer, serveTestHttpServerLayer } from "@rafads/sdk/testing";
+import {
+  AuthTemplateSlug,
+  ConnectionName,
+  IntegrationSlug,
+  ProviderItemId,
+  ProviderKey,
+  ToolAddress,
+  isToolResult
+} from "@rafads/sdk/core";
+var OpenApiTestServerAddressError = class extends Data.TaggedError(
+  "OpenApiTestServerAddressError"
+) {
+};
+var OpenApiTestServerSpecError = class extends Data.TaggedError("OpenApiTestServerSpecError") {
+};
+var addOpenApiTestConnection = (executor, server, integrationOptions, connectionOptions = {}) => Effect.gen(function* () {
+  const config = makeOpenApiTestIntegrationConfig(server, integrationOptions);
+  const result = yield* executor.openapi.addSpec(config);
+  const slug = String(result.slug);
+  const owner = connectionOptions.owner ?? "org";
+  const connection = connectionOptions.connection ?? "main";
+  const template = connectionOptions.template ?? "apiKey";
+  yield* executor.connections.create({
+    owner,
+    name: ConnectionName.make(connection),
+    integration: IntegrationSlug.make(slug),
+    template: AuthTemplateSlug.make(template),
+    ...connectionOptions.value !== void 0 ? { value: connectionOptions.value } : {
+      from: {
+        provider: ProviderKey.make("memory"),
+        id: ProviderItemId.make(`${slug}-token`)
+      }
+    }
+  });
+  return {
+    slug,
+    owner,
+    connection,
+    address: (tool) => ToolAddress.make(`tools.${slug}.${owner}.${connection}.${tool}`)
+  };
+});
+var makeOpenApiTestSpecJson = (api, options = {}) => {
+  const annotations = OpenApi.annotations({
+    ...options.baseUrl !== void 0 ? { servers: [{ url: options.baseUrl }] } : {},
+    transform: options.transformSpec
+  });
+  const annotated = api.annotateMerge(annotations);
+  return JSON.stringify(OpenApi.fromApi(annotated));
+};
+var makeOpenApiTestIntegrationConfig = (server, options) => {
+  const { baseUrl, slug, ...rest } = options;
+  return {
+    ...rest,
+    spec: { kind: "blob", value: server.specJson },
+    slug: slug ?? "test_api",
+    ...baseUrl === null ? {} : { baseUrl: baseUrl ?? server.baseUrl }
+  };
+};
+var addOpenApiTestIntegration = (executor, server, options) => executor.openapi.addSpec(makeOpenApiTestIntegrationConfig(server, options));
+var makeOpenApiHttpApiTestIntegrationConfig = (api, options) => {
+  const { baseUrl, specBaseUrl, transformSpec, slug, ...config } = options;
+  return {
+    ...config,
+    spec: {
+      kind: "blob",
+      value: makeOpenApiTestSpecJson(api, { baseUrl: specBaseUrl, transformSpec })
+    },
+    slug: slug ?? "test_api",
+    ...baseUrl === null ? {} : { baseUrl: baseUrl ?? specBaseUrl ?? "https://api.example.test" }
+  };
+};
+var addOpenApiHttpApiTestIntegration = (executor, api, options) => executor.openapi.addSpec(makeOpenApiHttpApiTestIntegrationConfig(api, options));
+var makeOpenApiHttpApiTestAddSpecPayload = (api, options) => {
+  const { headers, queryParams, ...integrationOptions } = options;
+  const config = makeOpenApiHttpApiTestIntegrationConfig(api, integrationOptions);
+  return {
+    spec: config.spec,
+    slug: config.slug,
+    baseUrl: config.baseUrl,
+    ...headers !== void 0 ? { headers } : {},
+    ...queryParams !== void 0 ? { queryParams } : {},
+    ...config.authenticationTemplate !== void 0 ? { authenticationTemplate: config.authenticationTemplate } : {}
+  };
+};
+var makeOpenApiHttpApiTestSpecPayload = (api, options = {}) => ({
+  spec: makeOpenApiTestSpecJson(api, options)
+});
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var OpenApiEchoItem = Schema.Struct({
+  id: Schema.Number,
+  name: Schema.String
+});
+var OpenApiEchoHeaders = Schema.Struct({
+  authorization: Schema.optional(Schema.String),
+  "x-static": Schema.optional(Schema.String)
+});
+var OpenApiEchoMessage = Schema.Struct({
+  message: Schema.String,
+  suffix: Schema.optional(Schema.String),
+  path: Schema.String
+});
+var OpenApiEchoItemsGroup = HttpApiGroup.make("items").add(
+  HttpApiEndpoint.get("listItems", "/items", {
+    success: Schema.Array(OpenApiEchoItem)
+  })
+).add(
+  HttpApiEndpoint.get("echoHeaders", "/echo-headers", {
+    success: OpenApiEchoHeaders
+  })
+);
+var OpenApiEchoGroup = HttpApiGroup.make("echo").add(
+  HttpApiEndpoint.get("echoMessage", "/echo/:message", {
+    params: Schema.Struct({ message: Schema.String }),
+    query: Schema.Struct({ suffix: Schema.optional(Schema.String) }),
+    success: OpenApiEchoMessage
+  })
+);
+var OpenApiEchoApi = HttpApi.make("executorOpenApiTest").add(OpenApiEchoItemsGroup).add(OpenApiEchoGroup).annotateMerge(
+  OpenApi.annotations({
+    title: "Executor OpenAPI Test Server",
+    version: "1.0.0"
+  })
+);
+var openApiSpecJsonFromHttpApi = (api, baseUrl, transformSpec) => Effect.try({
+  try: () => makeOpenApiTestSpecJson(api, { baseUrl, transformSpec }),
+  catch: (cause) => new OpenApiTestServerSpecError({ cause })
+});
+var serveOpenApiHttpApiTestServer = (options) => Effect.gen(function* () {
+  const specPath = options.specPath ?? "/spec.json";
+  let specJson = "";
+  const SpecRoute = HttpRouter.addAll([
+    HttpRouter.route(
+      "GET",
+      specPath,
+      Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        if (options.captureSpecRequest) {
+          yield* options.captureSpecRequest(request);
+        }
+        const guardResponse = options.guardSpecRequest ? yield* options.guardSpecRequest(request) : null;
+        if (guardResponse) return guardResponse;
+        return HttpServerResponse.text(specJson, {
+          status: 200,
+          contentType: "application/json"
+        });
+      })
+    )
+  ]);
+  const ApiLive = HttpApiBuilder.layer(options.api).pipe(
+    Layer.provide(options.handlersLayer)
+  );
+  const ServerLayer = HttpRouter.serve(Layer.mergeAll(ApiLive, SpecRoute), {
+    disableListenLog: true,
+    disableLogger: true
+  });
+  const server = yield* serveTestHttpServerLayer(ServerLayer).pipe(
+    Effect.mapError(
+      (error) => Predicate.isTagged(error, "TestHttpServerAddressError") ? new OpenApiTestServerAddressError({ address: error.address }) : new OpenApiTestServerSpecError({ cause: error.cause })
+    )
+  );
+  specJson = yield* openApiSpecJsonFromHttpApi(
+    options.api,
+    server.baseUrl,
+    options.transformSpec
+  );
+  return {
+    baseUrl: server.baseUrl,
+    specUrl: server.url(specPath),
+    specJson,
+    httpClientLayer: server.httpClientLayer
+  };
+});
+var OpenApiHttpApiTestServer = class _OpenApiHttpApiTestServer extends Context.Service()("@rafads/plugin-openapi/testing/OpenApiHttpApiTestServer") {
+  static layer = (options) => Layer.effect(_OpenApiHttpApiTestServer, serveOpenApiHttpApiTestServer(options));
+};
+var serveMutableOpenApiSpecTestServer = (options) => Effect.gen(function* () {
+  const specPath = options.specPath ?? "/spec.json";
+  const specJson = yield* Ref.make("");
+  const requests = yield* Ref.make(0);
+  const SpecRoute = HttpRouter.addAll([
+    HttpRouter.route(
+      "GET",
+      specPath,
+      Effect.gen(function* () {
+        yield* Ref.update(requests, (count) => count + 1);
+        const current = yield* Ref.get(specJson);
+        return HttpServerResponse.text(current, {
+          status: 200,
+          contentType: "application/json"
+        });
+      })
+    )
+  ]);
+  const server = yield* serveTestHttpServerLayer(
+    HttpRouter.serve(SpecRoute, {
+      disableListenLog: true,
+      disableLogger: true
+    })
+  ).pipe(
+    Effect.mapError(
+      (error) => Predicate.isTagged(error, "TestHttpServerAddressError") ? new OpenApiTestServerAddressError({ address: error.address }) : new OpenApiTestServerSpecError({ cause: error.cause })
+    )
+  );
+  const renderSpec = (api) => openApiSpecJsonFromHttpApi(api, server.baseUrl, options.transformSpec);
+  yield* Ref.set(specJson, yield* renderSpec(options.initialApi));
+  return {
+    baseUrl: server.baseUrl,
+    specUrl: server.url(specPath),
+    specJson: yield* Ref.get(specJson),
+    httpClientLayer: server.httpClientLayer,
+    setApi: (api) => renderSpec(api).pipe(Effect.flatMap((next) => Ref.set(specJson, next))),
+    requestCount: Ref.get(requests)
+  };
+});
+var openApiOperationMethods = /* @__PURE__ */ new Set([
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch"
+]);
+var withOAuth2Security = (oauth2) => (spec) => {
+  const scopes = oauth2.scopes ?? { read: "Read test resources" };
+  const security = [{ oauth2: Object.keys(scopes) }];
+  const paths = isJsonObject(spec.paths) ? Object.fromEntries(
+    Object.entries(spec.paths).map(([path, pathItem]) => [
+      path,
+      isJsonObject(pathItem) ? Object.fromEntries(
+        Object.entries(pathItem).map(([method, operation]) => [
+          method,
+          openApiOperationMethods.has(method) && isJsonObject(operation) ? { ...operation, security } : operation
+        ])
+      ) : pathItem
+    ])
+  ) : spec.paths;
+  const components = isJsonObject(spec.components) ? spec.components : {};
+  const securitySchemes = isJsonObject(components.securitySchemes) ? components.securitySchemes : {};
+  return {
+    ...spec,
+    paths,
+    components: {
+      ...components,
+      securitySchemes: {
+        ...securitySchemes,
+        oauth2: {
+          type: "oauth2",
+          flows: {
+            authorizationCode: {
+              authorizationUrl: oauth2.authorizationUrl,
+              tokenUrl: oauth2.tokenUrl,
+              scopes
+            }
+          }
+        }
+      }
+    }
+  };
+};
+var composeSpecTransforms = (...transforms) => (spec) => transforms.reduce((current, transform) => transform ? transform(current) : current, spec);
+var recordOpenApiRequest = (requests, request) => Effect.gen(function* () {
+  const url = new URL(request.url, "http://executor.test");
+  const body = yield* request.text.pipe(Effect.catch(() => Effect.succeed("")));
+  yield* Ref.update(requests, (all) => [
+    ...all,
+    {
+      method: request.method,
+      url: request.url,
+      path: url.pathname,
+      headers: request.headers,
+      body
+    }
+  ]);
+  return request;
+});
+var captureOpenApiRequest = (requests) => Effect.gen(function* () {
+  const request = yield* HttpServerRequest.HttpServerRequest;
+  return yield* recordOpenApiRequest(requests, request);
+});
+var openApiUnauthorizedResponse = (options, authorization) => options.oauth2?.validateAuthorization ? options.oauth2.validateAuthorization(authorization).pipe(
+  Effect.map(
+    (accepted) => accepted ? null : HttpServerResponse.jsonUnsafe(
+      { error: "invalid_token" },
+      options.oauth2?.wwwAuthenticate ? {
+        status: 401,
+        headers: {
+          "www-authenticate": options.oauth2.wwwAuthenticate
+        }
+      } : { status: 401 }
+    )
+  )
+) : Effect.succeed(null);
+var makeOpenApiEchoItemsGroupLive = (requests, options) => HttpApiBuilder.group(
+  OpenApiEchoApi,
+  "items",
+  (handlers) => handlers.handle(
+    "listItems",
+    () => Effect.gen(function* () {
+      const request = yield* captureOpenApiRequest(requests);
+      const unauthorized = yield* openApiUnauthorizedResponse(
+        options,
+        request.headers.authorization ?? null
+      );
+      if (unauthorized) return unauthorized;
+      return [
+        OpenApiEchoItem.make({ id: 1, name: "Widget" }),
+        OpenApiEchoItem.make({ id: 2, name: "Gadget" })
+      ];
+    })
+  ).handle(
+    "echoHeaders",
+    () => Effect.gen(function* () {
+      const request = yield* captureOpenApiRequest(requests);
+      const unauthorized = yield* openApiUnauthorizedResponse(
+        options,
+        request.headers.authorization ?? null
+      );
+      if (unauthorized) return unauthorized;
+      return OpenApiEchoHeaders.make({
+        authorization: request.headers.authorization,
+        "x-static": request.headers["x-static"]
+      });
+    })
+  )
+);
+var makeOpenApiEchoGroupLive = (requests, options) => HttpApiBuilder.group(
+  OpenApiEchoApi,
+  "echo",
+  (handlers) => handlers.handle(
+    "echoMessage",
+    ({ params, query }) => Effect.gen(function* () {
+      const request = yield* captureOpenApiRequest(requests);
+      const unauthorized = yield* openApiUnauthorizedResponse(
+        options,
+        request.headers.authorization ?? null
+      );
+      if (unauthorized) return unauthorized;
+      const path = `/echo/${encodeURIComponent(params.message)}`;
+      return OpenApiEchoMessage.make({
+        message: params.message,
+        ...query.suffix ? { suffix: query.suffix } : {},
+        path
+      });
+    })
+  )
+);
+var serveOpenApiEchoTestServer = (options = {}) => Effect.gen(function* () {
+  const requests = yield* Ref.make([]);
+  let specJson = "";
+  const server = yield* serveOpenApiHttpApiTestServer({
+    api: OpenApiEchoApi,
+    handlersLayer: Layer.mergeAll(
+      makeOpenApiEchoItemsGroupLive(requests, options),
+      makeOpenApiEchoGroupLive(requests, options)
+    ),
+    transformSpec: composeSpecTransforms(
+      options.oauth2 ? withOAuth2Security(options.oauth2) : void 0,
+      options.transformSpec
+    ),
+    captureSpecRequest: (request) => recordOpenApiRequest(requests, request).pipe(Effect.asVoid)
+  });
+  specJson = server.specJson;
+  return {
+    baseUrl: server.baseUrl,
+    specUrl: server.specUrl,
+    specJson,
+    httpClientLayer: server.httpClientLayer,
+    requests: Ref.get(requests),
+    clearRequests: Ref.set(requests, [])
+  };
+});
+var serveOpenApiEchoTestServerWithOAuth = (options = {}) => Effect.gen(function* () {
+  const oauth = yield* OAuthTestServer;
+  return yield* serveOpenApiEchoTestServer({
+    transformSpec: options.transformSpec,
+    oauth2: {
+      authorizationUrl: oauth.authorizationEndpoint,
+      tokenUrl: oauth.tokenEndpoint,
+      scopes: options.scopes,
+      validateAuthorization: oauth.acceptsAuthorizationHeader,
+      wwwAuthenticate: options.wwwAuthenticate
+    }
+  });
+});
+var OpenApiEchoTestServer = class _OpenApiEchoTestServer extends Context.Service()("@rafads/plugin-openapi/testing/OpenApiEchoTestServer") {
+  static layer = (options) => Layer.effect(_OpenApiEchoTestServer, serveOpenApiEchoTestServer(options));
+  static layerWithOAuth = (options) => Layer.effect(_OpenApiEchoTestServer, serveOpenApiEchoTestServerWithOAuth(options));
+};
+var TestLayers = {
+  httpApi: OpenApiHttpApiTestServer.layer,
+  echo: OpenApiEchoTestServer.layer,
+  echoWithOAuth: OpenApiEchoTestServer.layerWithOAuth
+};
+var unwrapInvocation = (raw) => {
+  if (!isToolResult(raw)) {
+    return {
+      status: null,
+      headers: null,
+      data: raw,
+      error: null
+    };
+  }
+  if (raw.ok) {
+    return {
+      status: raw.http?.status ?? null,
+      headers: raw.http?.headers ?? null,
+      data: raw.data,
+      error: null
+    };
+  }
+  return {
+    status: raw.error.status ?? null,
+    headers: null,
+    data: null,
+    error: raw.error.details ?? raw.error
+  };
+};
+export {
+  OpenApiEchoTestServer,
+  OpenApiHttpApiTestServer,
+  OpenApiTestServerAddressError,
+  OpenApiTestServerSpecError,
+  TestLayers,
+  addOpenApiHttpApiTestIntegration,
+  addOpenApiTestConnection,
+  addOpenApiTestIntegration,
+  makeOpenApiHttpApiTestAddSpecPayload,
+  makeOpenApiHttpApiTestIntegrationConfig,
+  makeOpenApiHttpApiTestSpecPayload,
+  makeOpenApiTestIntegrationConfig,
+  makeOpenApiTestSpecJson,
+  serveMutableOpenApiSpecTestServer,
+  serveOpenApiEchoTestServer,
+  serveOpenApiEchoTestServerWithOAuth,
+  serveOpenApiHttpApiTestServer,
+  unwrapInvocation
+};
+//# sourceMappingURL=testing.js.map