@executor-js/plugin-openapi 0.0.1 → 0.1.0

package/README.md

@@ -1,39 +1,36 @@
-# @executor/plugin-openapi
+# @executor-js/plugin-openapi
 
 Load [OpenAPI](https://www.openapis.org/) specifications into an executor. Every operation in the spec becomes an invokable tool with a JSON-Schema input, automatic request building, and optional secret-backed auth.
 
 ## Install
 
 ```sh
-bun add @executor/sdk @executor/plugin-openapi
+bun add @executor-js/sdk @executor-js/plugin-openapi
 # or
-npm install @executor/sdk @executor/plugin-openapi
+npm install @executor-js/sdk @executor-js/plugin-openapi
 ```
 
 ## Usage
 
 ```ts
-import { createExecutor } from "@executor/sdk";
-import { openApiPlugin } from "@executor/plugin-openapi";
+import { createExecutor } from "@executor-js/sdk";
+import { openApiPlugin } from "@executor-js/plugin-openapi";
 
 const executor = await createExecutor({
-  scope: { name: "my-app" },
+  onElicitation: "accept-all",
   plugins: [openApiPlugin()] as const,
 });
 
 // Load a spec by URL (JSON or YAML, remote or file://)
 await executor.openapi.addSpec({
+  scope: executor.scopes[0]!.id,
   spec: "https://petstore3.swagger.io/api/v3/openapi.json",
   namespace: "petstore",
 });
 
 // List and invoke tools like any other plugin
 const tools = await executor.tools.list();
-const result = await executor.tools.invoke(
-  "petstore.listPets",
-  {},
-  { onElicitation: "accept-all" },
-);
+const result = await executor.tools.invoke("petstore.listPets", {});
 ```
 
 ## Secret-backed auth headers
@@ -41,14 +38,26 @@ const result = await executor.tools.invoke(
 Wire API keys or bearer tokens through the executor's secret store — never hard-code them in source configs:
 
 ```ts
+import { createExecutor } from "@executor-js/sdk";
+import { openApiPlugin } from "@executor-js/plugin-openapi";
+import { fileSecretsPlugin } from "@executor-js/plugin-file-secrets";
+
+const executor = await createExecutor({
+  onElicitation: "accept-all",
+  plugins: [fileSecretsPlugin(), openApiPlugin()] as const,
+});
+
+const scope = executor.scopes[0]!.id;
+
 await executor.secrets.set({
   id: "stripe-key",
   name: "Stripe Key",
   value: "sk_live_...",
-  purpose: "authentication",
+  scope,
 });
 
 await executor.openapi.addSpec({
+  scope,
   spec: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",
   namespace: "stripe",
   headers: {
@@ -57,20 +66,12 @@ await executor.openapi.addSpec({
 });
 ```
 
-## Presets
-
-Common public APIs are available as presets from the `/presets` subpath:
-
-```ts
-import { openApiPresets } from "@executor/plugin-openapi/presets";
-```
-
-## Effect entry point
+## Using with Effect
 
-If you're using `@executor/core` directly, import from the `/core` subpath:
+If you're building on `@executor-js/sdk/core` (the raw Effect entry), import this plugin from its `/core` subpath instead — it returns the Effect-shaped plugin with `Effect.Effect<...>`-returning methods rather than promisified wrappers:
 
 ```ts
-import { openApiPlugin } from "@executor/plugin-openapi";
+import { openApiPlugin } from "@executor-js/plugin-openapi/core";
 ```
 
 ## Status

package/dist/api/group.d.ts

@@ -1,39 +1,95 @@
-import { HttpApiEndpoint, HttpApiGroup } from "@effect/platform";
-import { OpenApiParseError, OpenApiExtractionError } from "../sdk/errors";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Schema } from "effect";
+import { InternalError } from "@executor-js/api";
+import { OpenApiParseError, OpenApiExtractionError, OpenApiOAuthError } from "../sdk/errors";
 import { SpecPreview } from "../sdk/preview";
-import { StoredSourceSchema } from "../sdk/stored-source";
-declare const OpenApiGroup_base: HttpApiGroup.HttpApiGroup<"openapi", HttpApiEndpoint.HttpApiEndpoint<"previewSpec", "POST", {
-    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
-}, never, {
-    readonly spec: string;
-}, never, SpecPreview, OpenApiParseError | OpenApiExtractionError, never, never> | HttpApiEndpoint.HttpApiEndpoint<"addSpec", "POST", {
-    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
-}, never, {
-    readonly name?: string | undefined;
-    readonly namespace?: string | undefined;
-    readonly headers?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly baseUrl?: string | undefined;
-    readonly spec: string;
-}, never, {
-    readonly namespace: string;
-    readonly toolCount: number;
-}, OpenApiParseError | OpenApiExtractionError, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSource", "GET", {
-    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
-    readonly namespace: string;
-}, never, never, never, StoredSourceSchema | null, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateSource", "PATCH", {
-    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
-    readonly namespace: string;
-}, never, {
-    readonly name?: string | undefined;
-    readonly headers?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly baseUrl?: string | undefined;
-}, never, {
-    readonly updated: boolean;
-}, never, never, never>, never, never, false>;
-export declare class OpenApiGroup extends OpenApiGroup_base {
-}
-export {};
+import { StoredSourceSchema } from "../sdk/store";
+import { OAuth2Auth, OAuth2SourceConfig, OpenApiSourceBindingRef } from "../sdk/types";
+export declare const OpenApiGroup: HttpApiGroup.HttpApiGroup<"openapi", HttpApiEndpoint.HttpApiEndpoint<"previewSpec", "POST", "/scopes/:scopeId/openapi/preview", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly spec: 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>;
+        }>]>>>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<typeof SpecPreview>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"addSpec", "POST", "/scopes/:scopeId/openapi/specs", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly spec: 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 name: 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.Unknown>>;
+    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<Schema.Union<readonly [typeof OAuth2Auth, typeof OAuth2SourceConfig]>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly toolCount: Schema.Number;
+    readonly namespace: Schema.String;
+}>>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSource", "GET", "/scopes/:scopeId/openapi/sources/:namespace", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.NullOr<typeof StoredSourceSchema>>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateSource", "PATCH", "/scopes/:scopeId/openapi/sources/:namespace", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly name: Schema.optional<Schema.String>;
+    readonly baseUrl: Schema.optional<Schema.String>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    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<Schema.Union<readonly [typeof OAuth2Auth, typeof OAuth2SourceConfig]>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly updated: Schema.Boolean;
+}>>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listSourceBindings", "GET", "/scopes/:scopeId/openapi/sources/:namespace/base/:sourceScopeId/bindings", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+    sourceScopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.$Array<typeof OpenApiSourceBindingRef>>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"setSourceBinding", "POST", "/scopes/:scopeId/openapi/source-bindings", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly scope: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"secret">;
+        readonly secretId: Schema.brand<Schema.String, "SecretId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"connection">;
+        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>]>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<typeof OpenApiSourceBindingRef>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"removeSourceBinding", "POST", "/scopes/:scopeId/openapi/source-bindings/remove", HttpApiEndpoint.StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly scope: Schema.brand<Schema.String, "ScopeId">;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly removed: Schema.Boolean;
+}>>, HttpApiEndpoint.Json<typeof InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never>, false>;

package/dist/api/handlers.d.ts

@@ -1,7 +1,7 @@
 import { Context } from "effect";
 import type { OpenApiPluginExtension } from "../sdk/plugin";
-declare const OpenApiExtensionService_base: Context.TagClass<OpenApiExtensionService, "OpenApiExtensionService", OpenApiPluginExtension>;
+declare const OpenApiExtensionService_base: Context.ServiceClass<OpenApiExtensionService, "OpenApiExtensionService", OpenApiPluginExtension>;
 export declare class OpenApiExtensionService extends OpenApiExtensionService_base {
 }
-export declare const OpenApiHandlers: import("effect/Layer").Layer<import("@effect/platform/HttpApiGroup").ApiGroup<"executor", "openapi">, never, OpenApiExtensionService>;
+export declare const OpenApiHandlers: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").ApiGroup<"executor", "openapi">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", OpenApiExtensionService>>;
 export {};