Prefill spec overrides from the registry

Registry surfaces can carry RFC 6902 JSON Patch for a spec; the picker passes it through and the OpenAPI add flow prefills its overrides editor with it, so the patch is visible and editable rather than applied invisibly. A preset's own overrides win, and a user's draft wins over both. First use: Neon's spec declares the Neon console's session cookies as security schemes — the registry's patch removes them, and the add flow now offers exactly the real Bearer method.

Rhys Sullivan committed 2 months ago

Commit 12ae0911 parent 5d8aadd6 files · +51 −6Browse files

Unified · Split

6 files

packages/core/sdk/src/client.ts +4 −0
packages/plugins/openapi/src/react/AddOpenApiIntegration.tsx +12 −1
packages/react/src/lib/integrations-sh-catalog.ts +8 −0
packages/react/src/pages/integration-add.tsx +4 −1
packages/react/src/pages/integration-browse.tsx +18 −3
packages/react/src/routes/integrations.add.$pluginKey.tsx +5 −1

packages/core/sdk/src/client.ts+4−0

      *  still declare the right method — an authless MCP server is a fact the
      *  registry already knows. */
     readonly initialAuthKind?: string;
+    /** JSON-encoded RFC 6902 patch the registry says to apply to the fetched
+     *  spec — the registry's mechanism for improving a vendor's published
+     *  document over time without hosting a fork. */
+    readonly initialSpecOverrides?: string;
   }>;
   /** Legacy full-page edit surface. No host renders this anymore — plugin
    *  configuration lives in the integration Edit sheet via `editSheet`. */

packages/plugins/openapi/src/react/AddOpenApiIntegration.tsx+12−1

   initialNamespace?: string;
   initialAuthHeader?: string;
   initialAuthNote?: string;
+  initialSpecOverrides?: string;
 }) {
   const integrationPlugins = useIntegrationPlugins();
   const openApiPlugin = integrationPlugins.find((plugin) => plugin.key === "openapi");
   const activePreset = resolveOpenApiPreset(openApiPresets, props.initialPreset, specUrl);
   const presetSpecOverrides = decodeOpenApiSpecOverrides(activePreset?.specOverrides);
-  const specOverridesText = specOverridesDraft ?? formatSpecOverridesText(presetSpecOverrides);
+  // Registry-declared overrides — how a vendor's published document gets
+  // improved without hosting a fork (Neon's console session cookies posing as
+  // security schemes). A preset's own overrides win; the user's draft wins
+  // over both, and the editor shows exactly what will apply.
+  const registrySpecOverrides = useMemo(() => {
+    if (!props.initialSpecOverrides) return undefined;
+    const parsed = parseSpecOverridesText(props.initialSpecOverrides);
+    return parsed.ok ? parsed.value : undefined;
+  }, [props.initialSpecOverrides]);
+  const specOverridesText =
+    specOverridesDraft ?? formatSpecOverridesText(presetSpecOverrides ?? registrySpecOverrides);
   // After analysis
   const [preview, setPreview] = useState<SpecPreviewSummary | null>(null);

packages/react/src/lib/integrations-sh-catalog.ts+8−0

     readonly header?: string;
     readonly note?: string;
   };
+  /** RFC 6902 JSON Patch the registry says to apply to the fetched spec —
+   *  how a vendor's published document gets improved without hosting a fork
+   *  (e.g. Neon's console session cookies posing as security schemes). */
+  readonly specOverrides?: readonly unknown[];
 }
 export interface CatalogSearchEntry {
                 note: Schema.optional(Schema.String),
               }),
             ),
+            specOverrides: Schema.optional(Schema.Array(Schema.Unknown)),
           }),
         ),
       ),
                     slug: surface.slug,
                     ...(surface.url ? { url: surface.url } : {}),
                     ...(surface.auth ? { auth: surface.auth } : {}),
+                    ...(surface.specOverrides && surface.specOverrides.length > 0
+                      ? { specOverrides: surface.specOverrides }
+                      : {}),
                   },
                 ]
               : [],

packages/react/src/pages/integration-add.tsx+4−1

   authHeader?: string;
   authNote?: string;
   authKind?: string;
+  specOverrides?: string;
 }) {
   useExecutorDocumentTitle("Add integration");
-  const { pluginKey, url, preset, namespace, authHeader, authNote, authKind } = props;
+  const { pluginKey, url, preset, namespace, authHeader, authNote, authKind, specOverrides } =
+    props;
   const navigate = useNavigate();
   const integrationPlugins = useIntegrationPlugins();
   const refreshIntegrations = useAtomRefresh(integrationsOptimisticAtom);
             initialAuthHeader={authHeader}
             initialAuthNote={authNote}
             initialAuthKind={authKind}
+            initialSpecOverrides={specOverrides}
             onComplete={(slug?: string) => {
               trackEvent("integration_added", {
                 plugin_key: pluginKey,

packages/react/src/pages/integration-browse.tsx+18−3

       readonly slug?: string;
       readonly domain: string;
       readonly auth?: CatalogSurface["auth"];
+      readonly specOverrides?: CatalogSurface["specOverrides"];
     }) => {
       trackEvent("integration_add_started", {
         plugin_key: input.kind,
           ...(input.auth?.header ? { authHeader: input.auth.header } : {}),
           ...(input.auth?.note ? { authNote: input.auth.note } : {}),
           ...(input.auth?.kind ? { authKind: input.auth.kind } : {}),
+          ...(input.specOverrides ? { specOverrides: JSON.stringify(input.specOverrides) } : {}),
         },
       });
     },
           domain: entry.domain,
           ...(surface ? { slug: surface.slug } : {}),
           ...(surface?.auth ? { auth: surface.auth } : {}),
+          ...(surface?.specOverrides ? { specOverrides: surface.specOverrides } : {}),
         });
         return;
       }
   );
   const pickPreset = useCallback(
-    (entry: PresetEntry, auth?: CatalogSurface["auth"]) => {
+    (
+      entry: PresetEntry,
+      auth?: CatalogSurface["auth"],
+      specOverrides?: CatalogSurface["specOverrides"],
+    ) => {
       trackEvent("integration_add_started", {
         plugin_key: entry.pluginKey,
         via: "preset",
       if (auth?.header) search.authHeader = auth.header;
       if (auth?.note) search.authNote = auth.note;
       if (auth?.kind) search.authKind = auth.kind;
+      if (specOverrides) search.specOverrides = JSON.stringify(specOverrides);
       void navigate({
         to: "/{-$orgSlug}/integrations/add/$pluginKey",
         params: { pluginKey: entry.pluginKey },
   const catalogIdentityByKey = useMemo(() => {
     const map = new Map<
       string,
-      { readonly domain: string; readonly auth?: CatalogSurface["auth"] }
+      {
+        readonly domain: string;
+        readonly auth?: CatalogSurface["auth"];
+        readonly specOverrides?: CatalogSurface["specOverrides"];
+      }
     >();
     for (const entry of catalogEntries) {
       const pretty = entry.name ?? domainDisplayName(entry.domain);
           map.set(key, {
             domain: entry.domain,
             ...("auth" in surface && surface.auth ? { auth: surface.auth } : {}),
+            ...("specOverrides" in surface && surface.specOverrides
+              ? { specOverrides: surface.specOverrides }
+              : {}),
           });
         }
       }
         ...(identity ? { domain: identity.domain } : {}),
         ...(entry.preset.summary ? { description: entry.preset.summary } : {}),
         ...(entry.preset.icon ? { iconUrl: entry.preset.icon } : {}),
-        onSelect: () => pickPreset(entry, identity?.auth),
+        onSelect: () => pickPreset(entry, identity?.auth, identity?.specOverrides),
         added: isAdded(entry.pluginKey, entry.preset.defaultSlug, entry.preset.name),
         busy: false,
       });

packages/react/src/routes/integrations.add.$pluginKey.tsx+5−1

     authHeader: Schema.optional(Schema.String),
     authNote: Schema.optional(Schema.String),
     authKind: Schema.optional(Schema.String),
+    // JSON-encoded RFC 6902 patch the registry says to apply to the spec.
+    specOverrides: Schema.optional(Schema.String),
   }),
 );
   validateSearch: SearchParams,
   component: () => {
     const { pluginKey } = Route.useParams();
-    const { url, preset, namespace, authHeader, authNote, authKind } = Route.useSearch();
+    const { url, preset, namespace, authHeader, authNote, authKind, specOverrides } =
+      Route.useSearch();
     return (
       <AddIntegrationPage
         pluginKey={pluginKey}
         authHeader={authHeader}
         authNote={authNote}
         authKind={authKind}
+        specOverrides={specOverrides}
       />
     );
   },

Prefill spec overrides from the registry

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code