@executor-js/plugin-openapi 1.5.2 → 1.5.4

package/dist/testing/index.d.ts

@@ -0,0 +1,183 @@
+import { Context, Effect, Layer, Scope } from "effect";
+import { HttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpApi } from "effect/unstable/httpapi";
+import { OAuthTestServer } from "@executor-js/sdk/testing";
+import { IntegrationSlug, type Connection, type CreateConnectionInput, type Owner, type ToolAddress as ToolAddressType } from "@executor-js/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 OpenApiTestSourceOptions = Omit<OpenApiSpecConfig, "spec" | "baseUrl" | "slug"> & {
+    readonly baseUrl?: string | null;
+    readonly slug?: string;
+};
+export type OpenApiHttpApiTestSourceOptions = 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<OpenApiHttpApiTestSourceOptions, "headers" | "queryParams"> & OpenApiHttpApiAddSpecHeadersInput;
+export type OpenApiTestSourceExecutor = {
+    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, sourceOptions: OpenApiTestSourceOptions, 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 makeOpenApiTestSourceConfig: (server: OpenApiTestServerShape, options: OpenApiTestSourceOptions) => OpenApiSpecConfig;
+export declare const addOpenApiTestSource: (executor: OpenApiTestSourceExecutor, server: OpenApiTestServerShape, options: OpenApiTestSourceOptions) => Effect.Effect<{
+    readonly slug: IntegrationSlug;
+    readonly toolCount: number;
+}, import("@executor-js/sdk/core").StorageFailure | import("@executor-js/sdk/core").IntegrationAlreadyExistsError | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError, never>;
+export declare const makeOpenApiHttpApiTestSourceConfig: (api: HttpApi.Any, options: OpenApiHttpApiTestSourceOptions) => OpenApiSpecConfig;
+export declare const addOpenApiHttpApiTestSource: (executor: OpenApiTestSourceExecutor, api: HttpApi.Any, options: OpenApiHttpApiTestSourceOptions) => Effect.Effect<{
+    readonly slug: IntegrationSlug;
+    readonly toolCount: number;
+}, import("@executor-js/sdk/core").StorageFailure | import("@executor-js/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").Authentication[] | undefined;
+    queryParams?: Record<string, string> | undefined;
+    headers?: Record<string, string> | undefined;
+    spec: {
+        readonly kind: "url";
+        readonly url: string;
+    } | {
+        readonly value: string;
+        readonly kind: "blob";
+    } | {
+        readonly kind: "googleDiscovery";
+        readonly url: string;
+    } | {
+        readonly kind: "googleDiscoveryBundle";
+        readonly urls: readonly string[];
+    };
+    slug: string;
+    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, "@executor-js/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, "@executor-js/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.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executor-js/plugin-openapi",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/plugins/openapi",
   "bugs": {
     "url": "https://github.com/RhysSullivan/executor/issues"
@@ -52,29 +52,29 @@
     "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@effect/platform-node": "catalog:",
-    "@executor-js/config": "1.5.2",
-    "@executor-js/sdk": "1.5.2",
+    "@effect/platform-node": "4.0.0-beta.59",
+    "@executor-js/config": "1.5.4",
+    "@executor-js/sdk": "1.5.4",
     "lucide-react": "^1.7.0",
     "openapi-types": "^12.1.3",
     "yaml": "^2.7.1"
   },
   "devDependencies": {
-    "@effect/atom-react": "catalog:",
-    "@effect/vitest": "catalog:",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:",
-    "bun-types": "catalog:",
-    "effect": "catalog:",
-    "react": "catalog:",
-    "tsup": "catalog:",
-    "vitest": "catalog:"
+    "@effect/atom-react": "4.0.0-beta.59",
+    "@effect/vitest": "4.0.0-beta.59",
+    "@types/node": "^24.3.1",
+    "@types/react": "^19.1.0",
+    "bun-types": "^1.2.22",
+    "effect": "4.0.0-beta.59",
+    "react": "^19.1.0",
+    "tsup": "^8.5.0",
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "@effect/atom-react": "catalog:",
-    "@tanstack/react-router": "catalog:",
-    "effect": "catalog:",
-    "react": "catalog:"
+    "@effect/atom-react": "4.0.0-beta.59",
+    "@tanstack/react-router": "^1.168.10",
+    "effect": "4.0.0-beta.59",
+    "react": "^19.1.0"
   },
   "peerDependenciesMeta": {
     "react": {