@executor-js/plugin-openapi 0.0.1 → 0.1.0

package/dist/sdk/preview.d.ts

@@ -1,187 +1,112 @@
-import { Effect, Option } from "effect";
+import { Effect } from "effect";
 import { Schema } from "effect";
-declare const SecurityScheme_base: Schema.Class<SecurityScheme, {
-    /** Key name in components.securitySchemes (e.g. "api_token") */
-    name: typeof Schema.String;
-    /** OpenAPI security scheme type */
-    type: Schema.Literal<["http", "apiKey", "oauth2", "openIdConnect"]>;
-    /** For type: "http" — e.g. "bearer", "basic" */
-    scheme: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    /** For type: "apiKey" — where the key goes */
-    in: Schema.optionalWith<Schema.Literal<["header", "query", "cookie"]>, {
-        as: "Option";
-    }>;
-    /** For type: "apiKey" — the header/query/cookie name */
-    headerName: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
+import { ServerInfo } from "./types";
+declare const OAuth2AuthorizationCodeFlow_base: Schema.Class<OAuth2AuthorizationCodeFlow, Schema.Struct<{
+    readonly authorizationUrl: Schema.String;
+    readonly tokenUrl: Schema.String;
+    readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+    readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+}>, {}>;
+export declare class OAuth2AuthorizationCodeFlow extends OAuth2AuthorizationCodeFlow_base {
+}
+declare const OAuth2ClientCredentialsFlow_base: Schema.Class<OAuth2ClientCredentialsFlow, Schema.Struct<{
+    readonly tokenUrl: Schema.String;
+    readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+    readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+}>, {}>;
+export declare class OAuth2ClientCredentialsFlow extends OAuth2ClientCredentialsFlow_base {
+}
+declare const OAuth2Flows_base: Schema.Class<OAuth2Flows, Schema.Struct<{
+    readonly authorizationCode: Schema.OptionFromOptional<typeof OAuth2AuthorizationCodeFlow>;
+    readonly clientCredentials: Schema.OptionFromOptional<typeof OAuth2ClientCredentialsFlow>;
+}>, {}>;
+export declare class OAuth2Flows extends OAuth2Flows_base {
+}
+declare const SecurityScheme_base: Schema.Class<SecurityScheme, Schema.Struct<{
     /** Key name in components.securitySchemes (e.g. "api_token") */
-    name: typeof Schema.String;
+    readonly name: Schema.String;
     /** OpenAPI security scheme type */
-    type: Schema.Literal<["http", "apiKey", "oauth2", "openIdConnect"]>;
+    readonly type: Schema.Literals<readonly ["http", "apiKey", "oauth2", "openIdConnect"]>;
     /** For type: "http" — e.g. "bearer", "basic" */
-    scheme: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+    readonly scheme: Schema.OptionFromOptional<Schema.String>;
+    /** For type: "http" with scheme "bearer" — e.g. "JWT" */
+    readonly bearerFormat: Schema.OptionFromOptional<Schema.String>;
     /** For type: "apiKey" — where the key goes */
-    in: Schema.optionalWith<Schema.Literal<["header", "query", "cookie"]>, {
-        as: "Option";
-    }>;
+    readonly in: Schema.OptionFromOptional<Schema.Literals<readonly ["header", "query", "cookie"]>>;
     /** For type: "apiKey" — the header/query/cookie name */
-    headerName: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly description: Option.Option<string>;
-} & {
-    readonly type: "http" | "apiKey" | "oauth2" | "openIdConnect";
-} & {
-    readonly scheme: Option.Option<string>;
-} & {
-    readonly in: Option.Option<"query" | "header" | "cookie">;
-} & {
-    readonly headerName: Option.Option<string>;
-}, {}, {}>;
+    readonly headerName: Schema.OptionFromOptional<Schema.String>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+    /** For type: "oauth2" — declared flows (authorizationCode / clientCredentials only; implicit and password are deprecated). */
+    readonly flows: Schema.OptionFromOptional<typeof OAuth2Flows>;
+    /** For type: "openIdConnect" — the discovery URL. */
+    readonly openIdConnectUrl: Schema.OptionFromOptional<Schema.String>;
+}>, {}>;
 export declare class SecurityScheme extends SecurityScheme_base {
 }
-declare const AuthStrategy_base: Schema.Class<AuthStrategy, {
-    /** The security schemes required together for this strategy */
-    schemes: Schema.Array$<typeof Schema.String>;
-}, Schema.Struct.Encoded<{
+declare const AuthStrategy_base: Schema.Class<AuthStrategy, Schema.Struct<{
     /** The security schemes required together for this strategy */
-    schemes: Schema.Array$<typeof Schema.String>;
-}>, never, {
-    readonly schemes: readonly string[];
-}, {}, {}>;
+    readonly schemes: Schema.$Array<Schema.String>;
+}>, {}>;
 export declare class AuthStrategy extends AuthStrategy_base {
 }
-declare const HeaderPreset_base: Schema.Class<HeaderPreset, {
+declare const HeaderPreset_base: Schema.Class<HeaderPreset, Schema.Struct<{
     /** Human-readable label for the UI (e.g. "Bearer Token", "API Key + Email") */
-    label: typeof Schema.String;
+    readonly label: Schema.String;
     /** Headers this strategy needs. Value is null when the user must provide it. */
-    headers: Schema.Record$<typeof Schema.String, Schema.NullOr<typeof Schema.String>>;
+    readonly headers: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
     /** Which headers should be stored as secrets */
-    secretHeaders: Schema.Array$<typeof Schema.String>;
-}, Schema.Struct.Encoded<{
-    /** Human-readable label for the UI (e.g. "Bearer Token", "API Key + Email") */
-    label: typeof Schema.String;
-    /** Headers this strategy needs. Value is null when the user must provide it. */
-    headers: Schema.Record$<typeof Schema.String, Schema.NullOr<typeof Schema.String>>;
-    /** Which headers should be stored as secrets */
-    secretHeaders: Schema.Array$<typeof Schema.String>;
-}>, never, {
-    readonly headers: {
-        readonly [x: string]: string | null;
-    };
-} & {
-    readonly label: string;
-} & {
-    readonly secretHeaders: readonly string[];
-}, {}, {}>;
+    readonly secretHeaders: Schema.$Array<Schema.String>;
+}>, {}>;
 export declare class HeaderPreset extends HeaderPreset_base {
 }
-declare const PreviewOperation_base: Schema.Class<PreviewOperation, {
-    operationId: typeof Schema.String;
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    path: typeof Schema.String;
-    summary: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    tags: Schema.Array$<typeof Schema.String>;
-    deprecated: typeof Schema.Boolean;
-}, Schema.Struct.Encoded<{
-    operationId: typeof Schema.String;
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    path: typeof Schema.String;
-    summary: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    tags: Schema.Array$<typeof Schema.String>;
-    deprecated: typeof Schema.Boolean;
-}>, never, {
-    readonly tags: readonly string[];
-} & {
-    readonly summary: Option.Option<string>;
-} & {
-    readonly operationId: string;
-} & {
-    readonly deprecated: boolean;
-} & {
-    readonly path: string;
-} & {
-    readonly method: "delete" | "get" | "put" | "post" | "options" | "head" | "patch" | "trace";
-}, {}, {}>;
+declare const OAuth2Preset_base: Schema.Class<OAuth2Preset, Schema.Struct<{
+    /** Human-readable label for the UI (e.g. "OAuth2 (Authorization Code) — oauth_app") */
+    readonly label: Schema.String;
+    /** The source security scheme this preset came from (components.securitySchemes key). */
+    readonly securitySchemeName: Schema.String;
+    /** Which OAuth2 flow this preset uses. */
+    readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+    /** For authorizationCode: user-agent redirect URL (from the spec). */
+    readonly authorizationUrl: Schema.OptionFromOptional<Schema.String>;
+    /** Token endpoint to exchange the code / refresh. */
+    readonly tokenUrl: Schema.String;
+    /** Optional refresh endpoint if the spec declares one separately. */
+    readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+    /** Declared scopes for this flow: `{ scope: description }`. */
+    readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+}>, {}>;
+export declare class OAuth2Preset extends OAuth2Preset_base {
+}
+declare const PreviewOperation_base: Schema.Class<PreviewOperation, Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
+    readonly path: Schema.String;
+    readonly summary: Schema.OptionFromOptional<Schema.String>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly deprecated: Schema.Boolean;
+}>, {}>;
 export declare class PreviewOperation extends PreviewOperation_base {
 }
-declare const SpecPreview_base: Schema.Class<SpecPreview, {
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    /** Reuses ServerInfo from extraction */
-    servers: Schema.Array$<typeof Schema.Unknown>;
-    operationCount: typeof Schema.Number;
-    /** Lightweight operation list for the add-source UI */
-    operations: Schema.Array$<typeof PreviewOperation>;
-    tags: Schema.Array$<typeof Schema.String>;
-    securitySchemes: Schema.Array$<typeof SecurityScheme>;
-    /** Valid auth strategies (each is a set of schemes used together) */
-    authStrategies: Schema.Array$<typeof AuthStrategy>;
-    /** Pre-built header presets derived from auth strategies */
-    headerPresets: Schema.Array$<typeof HeaderPreset>;
-}, Schema.Struct.Encoded<{
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+declare const SpecPreview_base: Schema.Class<SpecPreview, Schema.Struct<{
+    readonly title: Schema.OptionFromOptional<Schema.String>;
+    readonly version: Schema.OptionFromOptional<Schema.String>;
     /** Reuses ServerInfo from extraction */
-    servers: Schema.Array$<typeof Schema.Unknown>;
-    operationCount: typeof Schema.Number;
+    readonly servers: Schema.$Array<typeof ServerInfo>;
+    readonly operationCount: Schema.Number;
     /** Lightweight operation list for the add-source UI */
-    operations: Schema.Array$<typeof PreviewOperation>;
-    tags: Schema.Array$<typeof Schema.String>;
-    securitySchemes: Schema.Array$<typeof SecurityScheme>;
+    readonly operations: Schema.$Array<typeof PreviewOperation>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly securitySchemes: Schema.$Array<typeof SecurityScheme>;
     /** Valid auth strategies (each is a set of schemes used together) */
-    authStrategies: Schema.Array$<typeof AuthStrategy>;
+    readonly authStrategies: Schema.$Array<typeof AuthStrategy>;
     /** Pre-built header presets derived from auth strategies */
-    headerPresets: Schema.Array$<typeof HeaderPreset>;
-}>, never, {
-    readonly title: Option.Option<string>;
-} & {
-    readonly servers: readonly unknown[];
-} & {
-    readonly tags: readonly string[];
-} & {
-    readonly version: Option.Option<string>;
-} & {
-    readonly securitySchemes: readonly SecurityScheme[];
-} & {
-    readonly operations: readonly PreviewOperation[];
-} & {
-    readonly operationCount: number;
-} & {
-    readonly authStrategies: readonly AuthStrategy[];
-} & {
-    readonly headerPresets: readonly HeaderPreset[];
-}, {}, {}>;
+    readonly headerPresets: Schema.$Array<typeof HeaderPreset>;
+    /** OAuth2 presets — one per (oauth2 scheme × supported flow) combination */
+    readonly oauth2Presets: Schema.$Array<typeof OAuth2Preset>;
+}>, {}>;
 export declare class SpecPreview extends SpecPreview_base {
 }
 /** Preview an OpenAPI spec — extract metadata without registering anything.
- *  Reuses parse() + extract() for the heavy lifting. */
-export declare const previewSpec: (specText: string) => Effect.Effect<SpecPreview, import("./errors").OpenApiParseError | import("./errors").OpenApiExtractionError, never>;
+ *  Accepts either a URL or raw JSON/YAML text. */
+export declare const previewSpec: (input: string) => Effect.Effect<SpecPreview, import("./errors").OpenApiParseError | import("./errors").OpenApiExtractionError, import("effect/unstable/http/HttpClient").HttpClient>;
 export {};

package/dist/sdk/store.d.ts

@@ -0,0 +1,201 @@
+import { Effect, Schema } from "effect";
+import { type StorageDeps, type StorageFailure } from "@executor-js/sdk/core";
+import { ConfiguredHeaderValue, ConfiguredHeaderBinding, HeaderValue, OAuth2Auth, OAuth2SourceConfig, OpenApiSourceBindingInput, OpenApiSourceBindingRef, OperationBinding } from "./types";
+export declare const openapiSchema: {
+    readonly openapi_source: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly spec: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly source_url: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly base_url: {
+                readonly type: "string";
+                readonly required: false;
+            };
+            readonly headers: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly query_params: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly oauth2: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly invocation_config: {
+                readonly type: "json";
+                readonly required: true;
+            };
+        };
+    };
+    readonly openapi_operation: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly binding: {
+                readonly type: "json";
+                readonly required: true;
+            };
+        };
+    };
+    readonly openapi_source_binding: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly target_scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly slot: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly value: {
+                readonly type: "json";
+                readonly required: true;
+            };
+            readonly created_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+            readonly updated_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+        };
+    };
+};
+export type OpenapiSchema = typeof openapiSchema;
+export interface SourceConfig {
+    readonly spec: string;
+    /** Origin URL when the spec was fetched from http(s). Absent for
+     *  raw-text adds. Persisted so `refreshSource` can re-fetch. */
+    readonly sourceUrl?: string;
+    readonly baseUrl?: string;
+    readonly namespace?: string;
+    readonly headers?: Record<string, ConfiguredHeaderValue>;
+    readonly queryParams?: Record<string, HeaderValue>;
+    readonly specFetchCredentials?: OpenApiSpecFetchCredentials;
+    readonly oauth2?: OAuth2SourceConfig;
+}
+export interface OpenApiSpecFetchCredentials {
+    readonly headers?: Record<string, HeaderValue>;
+    readonly queryParams?: Record<string, HeaderValue>;
+}
+export interface StoredSource {
+    readonly namespace: string;
+    /** Executor scope id this source row lives in. Writes stamp this on
+     *  `scope_id`; reads return whichever scope's row the adapter's
+     *  fall-through filter sees first. */
+    readonly scope: string;
+    readonly name: string;
+    readonly config: SourceConfig;
+    readonly legacy?: {
+        readonly headers?: Record<string, HeaderValue>;
+        readonly oauth2?: OAuth2Auth;
+    };
+}
+declare const StoredSourceSchema_base: Schema.Class<StoredSourceSchema, Schema.Struct<{
+    readonly namespace: Schema.String;
+    readonly name: Schema.String;
+    readonly config: Schema.Struct<{
+        readonly spec: Schema.String;
+        readonly sourceUrl: Schema.optional<Schema.String>;
+        readonly baseUrl: Schema.optional<Schema.String>;
+        readonly namespace: Schema.optional<Schema.String>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfiguredHeaderBinding]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+        readonly specFetchCredentials: Schema.optional<Schema.Struct<{
+            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly secretId: Schema.String;
+                readonly prefix: Schema.optional<Schema.String>;
+            }>]>>>;
+            readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly secretId: Schema.String;
+                readonly prefix: Schema.optional<Schema.String>;
+            }>]>>>;
+        }>>;
+        readonly oauth2: Schema.optional<typeof OAuth2SourceConfig>;
+    }>;
+}>, {}>;
+export declare class StoredSourceSchema extends StoredSourceSchema_base {
+}
+export type StoredSourceSchemaType = typeof StoredSourceSchema.Type;
+export interface StoredOperation {
+    readonly toolId: string;
+    readonly sourceId: string;
+    readonly binding: OperationBinding;
+}
+export declare const headerBindingSlot: (headerName: string) => string;
+export declare const oauth2ClientIdSlot: (securitySchemeName: string) => string;
+export declare const oauth2ClientSecretSlot: (securitySchemeName: string) => string;
+export declare const oauth2ConnectionSlot: (securitySchemeName: string) => string;
+export interface OpenapiStore {
+    readonly upsertSource: (input: StoredSource, operations: readonly StoredOperation[]) => Effect.Effect<void, StorageFailure>;
+    readonly updateSourceMeta: (namespace: string, scope: string, patch: {
+        readonly name?: string;
+        readonly baseUrl?: string;
+        readonly headers?: Record<string, ConfiguredHeaderValue>;
+        readonly queryParams?: Record<string, HeaderValue>;
+        readonly oauth2?: OAuth2SourceConfig;
+    }) => Effect.Effect<void, StorageFailure>;
+    readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredSource | null, StorageFailure>;
+    readonly listSources: () => Effect.Effect<readonly StoredSource[], StorageFailure>;
+    readonly getOperationByToolId: (toolId: string, scope: string) => Effect.Effect<StoredOperation | null, StorageFailure>;
+    readonly listOperationsBySource: (sourceId: string, scope: string) => Effect.Effect<readonly StoredOperation[], StorageFailure>;
+    readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
+    readonly listSourceBindings: (sourceId: string, sourceScope: string) => Effect.Effect<readonly OpenApiSourceBindingRef[], StorageFailure>;
+    readonly resolveSourceBinding: (sourceId: string, sourceScope: string, slot: string) => Effect.Effect<OpenApiSourceBindingRef | null, StorageFailure>;
+    readonly setSourceBinding: (input: OpenApiSourceBindingInput) => Effect.Effect<OpenApiSourceBindingRef, StorageFailure>;
+    readonly removeSourceBinding: (sourceId: string, sourceScope: string, slot: string, scope: string) => Effect.Effect<void, StorageFailure>;
+}
+export declare const makeDefaultOpenapiStore: ({ adapter, scopes, }: StorageDeps<OpenapiSchema>) => OpenapiStore;
+export {};