@objectstack/connector-openapi 7.4.0

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @objectstack/connector-openapi@7.4.0 build /home/runner/work/framework/framework/packages/connectors/connector-openapi
+> tsup --config ../../../tsup.config.ts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/framework/framework/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+CJS dist/index.js     8.82 KB
+CJS dist/index.js.map 25.11 KB
+CJS ⚡️ Build success in 94ms
+ESM dist/index.mjs     7.73 KB
+ESM dist/index.mjs.map 23.76 KB
+ESM ⚡️ Build success in 108ms
+DTS Build start
+DTS ⚡️ Build success in 8511ms
+DTS dist/index.d.mts 6.11 KB
+DTS dist/index.d.ts  6.11 KB

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# @objectstack/connector-openapi
+
+## 7.4.0
+
+### Minor Changes
+
+- 71d8ae1: Add `@objectstack/connector-openapi` — generate an ObjectStack connector from a declarative OpenAPI 3.x document (ADR-0023). One operation becomes one connector action; a single generic handler drives a self-contained static-auth HTTP transport (mirroring `@objectstack/connector-rest`). The generated `type: 'api'` connector registers via `engine.registerConnector(def, handlers)` with no new engine surface, and supports an `include` allowlist for trimming large specs.
+
+### Patch Changes
+
+- Updated dependencies [23c7107]
+- Updated dependencies [c72daad]
+- Updated dependencies [f115182]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [58b450b]
+- Updated dependencies [82eb6cf]
+- Updated dependencies [13d8653]
+- Updated dependencies [ff3d006]
+- Updated dependencies [5e831de]
+  - @objectstack/spec@7.4.0
+  - @objectstack/core@7.4.0

package/LICENSE

@@ -0,0 +1,93 @@
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             ObjectStack AI LLC
+Licensed Work:        ObjectStack Runtime: the BSL-licensed packages
+                      of the ObjectStack monorepo as listed in LICENSING.md.
+                      Copyright (c) 2026 ObjectStack AI LLC.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      Your use does not include offering the Licensed Work to third
+                      parties on a hosted or embedded basis in order to compete with 
+                      ObjectStack AI LLC's paid version(s) of the Licensed Work. For purposes 
+                      of this license:
+
+                      A "competitive offering" is a Product that is offered to third
+                      parties on a paid basis, including through paid support 
+                      arrangements, that significantly overlaps with the capabilities 
+                      of ObjectStack AI LLC's paid version(s) of the Licensed Work. If Your 
+                      Product is not a competitive offering when You first make it 
+                      generally available, it will not become a competitive offering
+                      later due to ObjectStack AI LLC releasing a new version of the Licensed 
+                      Work with additional capabilities. In addition, Products that 
+                      are not provided on a paid basis are not competitive.
+
+                      "Product" means software that is offered to end users to manage 
+                      in their own environments or offered as a service on a hosted 
+                      basis.
+
+                      "Embedded" means including the source code or executable code 
+                      from the Licensed Work in a competitive offering. "Embedded" 
+                      also means packaging the competitive offering in such a way 
+                      that the Licensed Work must be accessed or downloaded for the 
+                      competitive offering to operate.
+
+                      Hosting or using the Licensed Work(s) for internal purposes 
+                      within an organization is not considered a competitive 
+                      offering. ObjectStack AI LLC considers your organization to include all 
+                      of your affiliates under common control.
+
+                      For binding interpretive guidance on using ObjectStack AI LLC products 
+                      under the Business Source License, please visit our FAQ. 
+                      (see LICENSING.md in this repository)
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@objectstack.dev.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

package/dist/index.d.mts

@@ -0,0 +1,147 @@
+import { Connector } from '@objectstack/spec/integration';
+
+/**
+ * OpenAPI connector generator — turns a declarative OpenAPI 3.x document into a
+ * {@link Connector} definition + handler map (ADR-0023).
+ *
+ * Each OpenAPI operation maps to one connector action; a single generic handler
+ * (closing over the operation's method + path template) drives one shared HTTP
+ * request implementation. That transport mirrors `@objectstack/connector-rest`
+ * (build URL from base+path+query, apply static auth, JSON-encode the body,
+ * normalise the response to `{ status, ok, body }`) — kept inline so this package
+ * stays self-contained, depending only on `@objectstack/core` + `@objectstack/spec`
+ * like its sibling connectors. The output is an ordinary `type: 'api'` connector,
+ * registered via `engine.registerConnector(def, handlers)` exactly like a
+ * hand-written one — the registry, the `connector_action` node, the discovery
+ * route, and the Studio palette never know it came from OpenAPI.
+ *
+ * Open-source scope: **static** auth only (`none` / `api-key` / `basic` /
+ * `bearer`), with credentials supplied by the caller. Managed OAuth2, credential
+ * vaulting, and per-tenant lifecycle are the enterprise tier (ADR-0015 / 0022).
+ */
+/** Static auth understood by the generated connector (the open-source subset). */
+type RestAuth = Extract<Connector['authentication'], {
+    type: 'none' | 'api-key' | 'basic' | 'bearer';
+}>;
+/** Handler signature accepted by the connector registry (ADR-0018 §Addendum). */
+type ConnectorHandler = (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>;
+/** A connector definition paired with its action handlers, ready for registerConnector(). */
+interface OpenApiConnectorBundle {
+    def: Connector;
+    handlers: Record<string, ConnectorHandler>;
+}
+/** A free-form JSON Schema fragment (matches ConnectorAction input/outputSchema). */
+type JsonSchema = Record<string, unknown>;
+/** Minimal subset of an OpenAPI 3.x document consumed by the generator.
+ *  The caller is responsible for loading and de-referencing ($ref) the doc. */
+interface OpenApiDocument {
+    openapi?: string;
+    info?: {
+        title?: string;
+        description?: string;
+        version?: string;
+    };
+    servers?: {
+        url: string;
+    }[];
+    paths?: Record<string, OpenApiPathItem>;
+    components?: {
+        securitySchemes?: Record<string, OpenApiSecurityScheme>;
+    };
+}
+interface OpenApiPathItem {
+    [method: string]: OpenApiOperation | unknown;
+}
+interface OpenApiOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenApiParameter[];
+    requestBody?: OpenApiRequestBody;
+    responses?: Record<string, OpenApiResponse>;
+}
+interface OpenApiParameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required?: boolean;
+    description?: string;
+    schema?: JsonSchema;
+}
+interface OpenApiRequestBody {
+    required?: boolean;
+    description?: string;
+    content?: Record<string, {
+        schema?: JsonSchema;
+    }>;
+}
+interface OpenApiResponse {
+    description?: string;
+    content?: Record<string, {
+        schema?: JsonSchema;
+    }>;
+}
+interface OpenApiSecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    name?: string;
+    in?: 'header' | 'query' | 'cookie';
+    scheme?: string;
+}
+/** Flattened view of a single operation, passed to the `include` predicate. */
+interface OperationInfo {
+    operationId?: string;
+    method: string;
+    path: string;
+    tags?: string[];
+    summary?: string;
+    description?: string;
+}
+/** Configuration for {@link createOpenApiConnector}. */
+interface OpenApiConnectorConfig {
+    /** Connector machine name (snake_case). Defaults to a slug of info.title. */
+    name?: string;
+    /** Human-friendly label. Defaults to info.title (then name). */
+    label?: string;
+    /** Description. Defaults to info.description. */
+    description?: string;
+    /** Icon identifier for the Studio palette. Defaults to `globe`. */
+    icon?: string;
+    /** The parsed OpenAPI 3.x document (caller loads/derefs it). */
+    document: OpenApiDocument;
+    /** Override the base URL (else servers[0].url). */
+    baseUrl?: string;
+    /** Static auth with credentials. Defaults to `{ type: 'none' }`. */
+    auth?: RestAuth;
+    /** Headers merged into every request (request-level headers win). */
+    defaultHeaders?: Record<string, string>;
+    /** Only include operations for which this predicate returns true (allowlist). */
+    include?: (op: OperationInfo) => boolean;
+    /** Injected fetch implementation (defaults to global `fetch`). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Build an OpenAPI connector definition and its handler map.
+ *
+ * @returns the `Connector` definition (`def`) and a `handlers` record keyed by
+ * action key, suitable for `engine.registerConnector(def, handlers)`.
+ */
+declare function createOpenApiConnector(config: OpenApiConnectorConfig): OpenApiConnectorBundle;
+
+/**
+ * Minimal surface of the automation engine this helper depends on — the
+ * connector registry from ADR-0018 §Addendum. Kept structural so callers need
+ * no runtime dependency on `@objectstack/service-automation` (mirrors
+ * connector-rest / connector-mcp).
+ */
+interface ConnectorRegistrySurface {
+    registerConnector(def: Connector, handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>): void;
+    unregisterConnector(name: string): void;
+}
+/**
+ * Generate an OpenAPI-backed connector and register it on the engine's connector
+ * registry so the baseline `connector_action` node can dispatch to the generated
+ * actions (ADR-0023). Returns the registered connector name.
+ */
+declare function registerOpenApiConnector(registry: ConnectorRegistrySurface, config: OpenApiConnectorConfig): string;
+
+export { type ConnectorRegistrySurface, type JsonSchema, type OpenApiConnectorBundle, type OpenApiConnectorConfig, type OpenApiDocument, type OpenApiOperation, type OpenApiParameter, type OpenApiPathItem, type OpenApiRequestBody, type OpenApiResponse, type OpenApiSecurityScheme, type OperationInfo, type RestAuth, createOpenApiConnector, registerOpenApiConnector };

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { Connector } from '@objectstack/spec/integration';
+
+/**
+ * OpenAPI connector generator — turns a declarative OpenAPI 3.x document into a
+ * {@link Connector} definition + handler map (ADR-0023).
+ *
+ * Each OpenAPI operation maps to one connector action; a single generic handler
+ * (closing over the operation's method + path template) drives one shared HTTP
+ * request implementation. That transport mirrors `@objectstack/connector-rest`
+ * (build URL from base+path+query, apply static auth, JSON-encode the body,
+ * normalise the response to `{ status, ok, body }`) — kept inline so this package
+ * stays self-contained, depending only on `@objectstack/core` + `@objectstack/spec`
+ * like its sibling connectors. The output is an ordinary `type: 'api'` connector,
+ * registered via `engine.registerConnector(def, handlers)` exactly like a
+ * hand-written one — the registry, the `connector_action` node, the discovery
+ * route, and the Studio palette never know it came from OpenAPI.
+ *
+ * Open-source scope: **static** auth only (`none` / `api-key` / `basic` /
+ * `bearer`), with credentials supplied by the caller. Managed OAuth2, credential
+ * vaulting, and per-tenant lifecycle are the enterprise tier (ADR-0015 / 0022).
+ */
+/** Static auth understood by the generated connector (the open-source subset). */
+type RestAuth = Extract<Connector['authentication'], {
+    type: 'none' | 'api-key' | 'basic' | 'bearer';
+}>;
+/** Handler signature accepted by the connector registry (ADR-0018 §Addendum). */
+type ConnectorHandler = (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>;
+/** A connector definition paired with its action handlers, ready for registerConnector(). */
+interface OpenApiConnectorBundle {
+    def: Connector;
+    handlers: Record<string, ConnectorHandler>;
+}
+/** A free-form JSON Schema fragment (matches ConnectorAction input/outputSchema). */
+type JsonSchema = Record<string, unknown>;
+/** Minimal subset of an OpenAPI 3.x document consumed by the generator.
+ *  The caller is responsible for loading and de-referencing ($ref) the doc. */
+interface OpenApiDocument {
+    openapi?: string;
+    info?: {
+        title?: string;
+        description?: string;
+        version?: string;
+    };
+    servers?: {
+        url: string;
+    }[];
+    paths?: Record<string, OpenApiPathItem>;
+    components?: {
+        securitySchemes?: Record<string, OpenApiSecurityScheme>;
+    };
+}
+interface OpenApiPathItem {
+    [method: string]: OpenApiOperation | unknown;
+}
+interface OpenApiOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenApiParameter[];
+    requestBody?: OpenApiRequestBody;
+    responses?: Record<string, OpenApiResponse>;
+}
+interface OpenApiParameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required?: boolean;
+    description?: string;
+    schema?: JsonSchema;
+}
+interface OpenApiRequestBody {
+    required?: boolean;
+    description?: string;
+    content?: Record<string, {
+        schema?: JsonSchema;
+    }>;
+}
+interface OpenApiResponse {
+    description?: string;
+    content?: Record<string, {
+        schema?: JsonSchema;
+    }>;
+}
+interface OpenApiSecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    name?: string;
+    in?: 'header' | 'query' | 'cookie';
+    scheme?: string;
+}
+/** Flattened view of a single operation, passed to the `include` predicate. */
+interface OperationInfo {
+    operationId?: string;
+    method: string;
+    path: string;
+    tags?: string[];
+    summary?: string;
+    description?: string;
+}
+/** Configuration for {@link createOpenApiConnector}. */
+interface OpenApiConnectorConfig {
+    /** Connector machine name (snake_case). Defaults to a slug of info.title. */
+    name?: string;
+    /** Human-friendly label. Defaults to info.title (then name). */
+    label?: string;
+    /** Description. Defaults to info.description. */
+    description?: string;
+    /** Icon identifier for the Studio palette. Defaults to `globe`. */
+    icon?: string;
+    /** The parsed OpenAPI 3.x document (caller loads/derefs it). */
+    document: OpenApiDocument;
+    /** Override the base URL (else servers[0].url). */
+    baseUrl?: string;
+    /** Static auth with credentials. Defaults to `{ type: 'none' }`. */
+    auth?: RestAuth;
+    /** Headers merged into every request (request-level headers win). */
+    defaultHeaders?: Record<string, string>;
+    /** Only include operations for which this predicate returns true (allowlist). */
+    include?: (op: OperationInfo) => boolean;
+    /** Injected fetch implementation (defaults to global `fetch`). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Build an OpenAPI connector definition and its handler map.
+ *
+ * @returns the `Connector` definition (`def`) and a `handlers` record keyed by
+ * action key, suitable for `engine.registerConnector(def, handlers)`.
+ */
+declare function createOpenApiConnector(config: OpenApiConnectorConfig): OpenApiConnectorBundle;
+
+/**
+ * Minimal surface of the automation engine this helper depends on — the
+ * connector registry from ADR-0018 §Addendum. Kept structural so callers need
+ * no runtime dependency on `@objectstack/service-automation` (mirrors
+ * connector-rest / connector-mcp).
+ */
+interface ConnectorRegistrySurface {
+    registerConnector(def: Connector, handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>): void;
+    unregisterConnector(name: string): void;
+}
+/**
+ * Generate an OpenAPI-backed connector and register it on the engine's connector
+ * registry so the baseline `connector_action` node can dispatch to the generated
+ * actions (ADR-0023). Returns the registered connector name.
+ */
+declare function registerOpenApiConnector(registry: ConnectorRegistrySurface, config: OpenApiConnectorConfig): string;
+
+export { type ConnectorRegistrySurface, type JsonSchema, type OpenApiConnectorBundle, type OpenApiConnectorConfig, type OpenApiDocument, type OpenApiOperation, type OpenApiParameter, type OpenApiPathItem, type OpenApiRequestBody, type OpenApiResponse, type OpenApiSecurityScheme, type OperationInfo, type RestAuth, createOpenApiConnector, registerOpenApiConnector };

package/dist/index.js

@@ -0,0 +1,252 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createOpenApiConnector: () => createOpenApiConnector,
+  registerOpenApiConnector: () => registerOpenApiConnector
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/openapi-connector.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "patch", "options", "head", "trace"];
+function createOpenApiConnector(config) {
+  const { document, include } = config;
+  const auth = config.auth ?? { type: "none" };
+  const doFetch = config.fetchImpl ?? fetch;
+  const name = config.name ?? slug(document.info?.title ?? "openapi_connector");
+  const label = config.label ?? document.info?.title ?? titleize(name);
+  const description = config.description ?? document.info?.description;
+  const baseUrl = config.baseUrl ?? document.servers?.[0]?.url;
+  if (!baseUrl) {
+    throw new Error("createOpenApiConnector: no base URL \u2014 provide config.baseUrl or document.servers[0].url");
+  }
+  async function request(input) {
+    const method = input.method.toUpperCase();
+    const headers = { ...config.defaultHeaders, ...input.headers };
+    const query = { ...input.query };
+    applyAuth(auth, headers, query);
+    const url = buildUrl(baseUrl, input.path, query);
+    const hasBody = input.body !== void 0 && method !== "GET" && method !== "HEAD";
+    if (hasBody && headers["Content-Type"] === void 0 && headers["content-type"] === void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await doFetch(url, {
+      method,
+      headers,
+      body: hasBody ? JSON.stringify(input.body) : void 0
+    });
+    const contentType = response.headers.get("content-type") ?? "";
+    const parsed = contentType.includes("application/json") ? await response.json() : await response.text();
+    return { status: response.status, ok: response.ok, body: parsed };
+  }
+  const actions = [];
+  const handlers = {};
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const op of collectOperations(document)) {
+    if (include && !include(toInfo(op))) continue;
+    const key = uniqueKey(op.operationId ?? slug(`${op.method}_${op.path}`), seenKeys);
+    actions.push({
+      key,
+      label: op.summary ?? titleize(key),
+      description: op.description,
+      inputSchema: buildInputSchema(op),
+      outputSchema: buildOutputSchema(op)
+    });
+    handlers[key] = async (input) => {
+      const req = input;
+      return request({
+        method: op.method,
+        path: interpolatePath(op.path, asRecord(req.path)),
+        query: stringifyValues(asRecord(req.query)),
+        headers: stringifyValues(asRecord(req.header)),
+        body: req.body
+      });
+    };
+  }
+  const def = {
+    name,
+    label,
+    type: "api",
+    description,
+    icon: config.icon ?? "globe",
+    authentication: auth,
+    // Defaulted by ConnectorSchema; set explicitly so the literal satisfies
+    // the (post-parse) Connector output type (mirrors connector-rest/mcp).
+    status: "active",
+    enabled: true,
+    connectionTimeoutMs: 3e4,
+    requestTimeoutMs: 3e4,
+    actions
+  };
+  return { def, handlers };
+}
+function collectOperations(doc) {
+  const ops = [];
+  for (const [path, item] of Object.entries(doc.paths ?? {})) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    for (const method of HTTP_METHODS) {
+      const operation = record[method];
+      if (!operation || typeof operation !== "object") continue;
+      ops.push({ ...operation, method, path });
+    }
+  }
+  return ops;
+}
+function toInfo(op) {
+  return {
+    operationId: op.operationId,
+    method: op.method,
+    path: op.path,
+    tags: op.tags,
+    summary: op.summary,
+    description: op.description
+  };
+}
+function buildInputSchema(op) {
+  const sections = {
+    path: { props: {}, required: [] },
+    query: { props: {}, required: [] },
+    header: { props: {}, required: [] }
+  };
+  for (const p of op.parameters ?? []) {
+    if (!p || typeof p !== "object" || "$ref" in p) continue;
+    if (p.in !== "path" && p.in !== "query" && p.in !== "header") continue;
+    const sec = sections[p.in];
+    sec.props[p.name] = p.schema ?? (p.description ? { type: "string", description: p.description } : { type: "string" });
+    if (p.required) sec.required.push(p.name);
+  }
+  const properties = {};
+  const required = [];
+  for (const where of ["path", "query", "header"]) {
+    const sec = sections[where];
+    if (Object.keys(sec.props).length === 0) continue;
+    const schema2 = { type: "object", properties: sec.props };
+    if (sec.required.length) schema2.required = sec.required;
+    properties[where] = schema2;
+    if (where === "path" || sec.required.length) required.push(where);
+  }
+  const bodySchema = extractRequestBodySchema(op.requestBody);
+  if (bodySchema) {
+    properties.body = bodySchema;
+    if (op.requestBody && !("$ref" in op.requestBody) && op.requestBody.required) required.push("body");
+  }
+  if (Object.keys(properties).length === 0) return void 0;
+  const schema = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+function buildOutputSchema(op) {
+  const responses = op.responses;
+  if (!responses) return void 0;
+  let code;
+  if (responses["200"]) code = "200";
+  else code = Object.keys(responses).find((c) => /^2\d\d$/.test(c));
+  if (!code && responses["default"]) code = "default";
+  if (!code) return void 0;
+  const resp = responses[code];
+  if (!resp || typeof resp !== "object" || "$ref" in resp) return void 0;
+  return pickJsonSchema(resp.content);
+}
+function extractRequestBodySchema(rb) {
+  if (!rb || typeof rb !== "object" || "$ref" in rb) return void 0;
+  return pickJsonSchema(rb.content);
+}
+function pickJsonSchema(content) {
+  if (!content) return void 0;
+  const chosen = content["application/json"] ?? Object.values(content)[0];
+  return chosen?.schema;
+}
+function buildUrl(baseUrl, path, query) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const suffix = path ? path.startsWith("/") ? path : `/${path}` : "";
+  const url = new URL(base + suffix);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function applyAuth(auth, headers, query) {
+  switch (auth.type) {
+    case "none":
+      return;
+    case "bearer":
+      headers["Authorization"] = `Bearer ${auth.token}`;
+      return;
+    case "basic": {
+      const encoded = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+      headers["Authorization"] = `Basic ${encoded}`;
+      return;
+    }
+    case "api-key":
+      if (auth.paramName) query[auth.paramName] = auth.key;
+      else headers[auth.headerName ?? "X-API-Key"] = auth.key;
+      return;
+  }
+}
+function interpolatePath(template, pathParams) {
+  return template.replace(/\{([^}]+)\}/g, (_match, key) => {
+    const value = pathParams[key];
+    return value === void 0 || value === null ? `{${key}}` : encodeURIComponent(String(value));
+  });
+}
+function stringifyValues(rec) {
+  const out = {};
+  for (const [k, v] of Object.entries(rec)) {
+    if (v === void 0 || v === null) continue;
+    out[k] = String(v);
+  }
+  return out;
+}
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function uniqueKey(base, seen) {
+  let candidate = base;
+  if (seen.has(candidate)) {
+    let i = 2;
+    while (seen.has(`${base}_${i}`)) i++;
+    candidate = `${base}_${i}`;
+  }
+  seen.add(candidate);
+  return candidate;
+}
+function slug(s) {
+  const out = s.normalize("NFKD").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  if (!out) return "connector";
+  return /^[a-z_]/.test(out) ? out : `op_${out}`;
+}
+function titleize(name) {
+  return name.split("_").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
+// src/connector-openapi-plugin.ts
+function registerOpenApiConnector(registry, config) {
+  const { def, handlers } = createOpenApiConnector(config);
+  registry.registerConnector(def, handlers);
+  return def.name;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createOpenApiConnector,
+  registerOpenApiConnector
+});
+//# sourceMappingURL=index.js.map