Stop editing an OAuth app from clearing its recorded origin

createClient is delete-then-create, so the edit flow resubmitting originIntegration: null was wiping the intent stamp the picker matches on. The form now takes an explicit intentIntegration that the edit dialog fills from the summary origin; fresh registrations keep stamping the current integration.

Rhys Sullivan committed 4 months ago

Commit 9b8b2b01 parent e9ee6663 files · +63 −4Browse files

Unified · Split

3 files

packages/react/src/components/add-account-modal.tsx +9 −0
packages/react/src/components/oauth-client-form.test.ts +29 −1
packages/react/src/components/oauth-client-form.tsx +25 −3

packages/react/src/components/add-account-modal.tsx+9−0

@@ -1593,6 +1593,15 @@ function AddAccountModalView(props: AddAccountModalProps) { · 1592 unmodified lines
1593	existingSlugs={clientSummaries.map((c: OAuthClientSummary) => String(c.slug))}	1593	existingSlugs={clientSummaries.map((c: OAuthClientSummary) => String(c.slug))}
1594	fixedSlug={editingClient.slug}	1594	fixedSlug={editingClient.slug}
1595	fixedOwner={editingClient.owner}	1595	fixedOwner={editingClient.owner}
		1596	// Preserve the app's already-recorded origin verbatim (only a
		1597	// "manual" origin carries a recorded integration; DCR apps
		1598	// aren't edited through this form). Editing must never
		1599	// re-derive this from the current dialog's integration.
		1600	intentIntegration={
		1601	editingClient.origin.kind === "manual"
		1602	? (editingClient.origin.integration ?? null)
		1603	: null
		1604	}
1596	prefill={{	1605	prefill={{
1597	authorizationUrl: editingClient.authorizationUrl,	1606	authorizationUrl: editingClient.authorizationUrl,
1598	tokenUrl: editingClient.tokenUrl,	1607	tokenUrl: editingClient.tokenUrl,

packages/react/src/components/oauth-client-form.test.ts+29−1

@@ -1,6 +1,11 @@
1	import { describe, expect, it } from "@effect/vitest";	1	import { describe, expect, it } from "@effect/vitest";
		2	import { IntegrationSlug } from "@executor-js/sdk/shared";
2		3
3	import { canSubmitOAuthClientForm, registrationScopes } from "./oauth-client-form";	4	import {
		5	canSubmitOAuthClientForm,
		6	registrationScopes,
		7	resolveOriginIntegration,
		8	} from "./oauth-client-form";
4		9
5	const validBase = {	10	const validBase = {
6	submitting: false,	11	submitting: false,
@@ -36,6 +41,29 @@ describe("registrationScopes", () => { · 29 unmodified lines
36	});	41	});
37	});	42	});
38		43
		44	describe("resolveOriginIntegration", () => {
		45	const INTEG = IntegrationSlug.make("linear_mcp");
		46	const OTHER = IntegrationSlug.make("github");
		47
		48	it("stamps the current integration for a fresh registration (no explicit intent)", () => {
		49	expect(resolveOriginIntegration(undefined, INTEG)).toBe(INTEG);
		50	});
		51
		52	it("stamps null for a fresh registration outside any integration context", () => {
		53	expect(resolveOriginIntegration(undefined, undefined)).toBeNull();
		54	});
		55
		56	it("preserves an explicit null intent when editing — does NOT re-stamp the current integration", () => {
		57	// Regression: editing used to send `fixedSlug ? null : integrationSlug`,
		58	// which clobbered an app's recorded origin with null on every edit.
		59	expect(resolveOriginIntegration(null, INTEG)).toBeNull();
		60	});
		61
		62	it("preserves an explicit non-null intent when editing, even if it differs from the current integration", () => {
		63	expect(resolveOriginIntegration(OTHER, INTEG)).toBe(OTHER);
		64	});
		65	});
		66
39	describe("canSubmitOAuthClientForm", () => {	67	describe("canSubmitOAuthClientForm", () => {
40	it("allows authorization-code public clients with no client secret", () => {	68	it("allows authorization-code public clients with no client secret", () => {
41	expect(	69	expect(

packages/react/src/components/oauth-client-form.tsx+25−3

   discoveredScopes: readonly string[],
 ): readonly string[] => (declaredScopes.length > 0 ? declaredScopes : discoveredScopes);
+/** The `originIntegration` to send with a `createClient` payload. When the
+ *  caller passes an explicit `intentIntegration` (edit flow: the app's
+ *  preserved recorded intent, which may legitimately be `null`), it wins
+ *  verbatim — editing must never silently overwrite a stamp. Otherwise this is
+ *  a fresh registration from an integration's dialog, which stamps the current
+ *  integration as recorded intent (or `null` outside any integration
+ *  context). */
+export const resolveOriginIntegration = (
+  intentIntegration: IntegrationSlug | null | undefined,
+  integrationSlug: IntegrationSlug | undefined,
+): IntegrationSlug | null =>
+  intentIntegration !== undefined ? intentIntegration : (integrationSlug ?? null);
 export const canSubmitOAuthClientForm = (input: {
   readonly submitting: boolean;
   readonly name: string;
    *  when editing (an existing app's origin is fixed) or when there is no single
    *  integration context. */
   readonly integrationSlug?: IntegrationSlug;
+  /** Explicit recorded-intent stamp to send verbatim, overriding the default
+   *  derivation from `integrationSlug`. Set this when editing an existing app
+   *  so its ALREADY-recorded origin (which may be `null`) is preserved rather
+   *  than re-derived from the current dialog's integration context. Omit for a
+   *  fresh registration, where the default (stamp `integrationSlug`, or `null`
+   *  outside an integration context) is correct. */
+  readonly intentIntegration?: IntegrationSlug | null;
   /** Existing client slugs, so the generated slug stays unique across apps. */
   readonly existingSlugs: readonly string[];
   /** Endpoints/scopes declared by the integration's OAuth method. */
   const {
     integrationName,
     integrationSlug,
+    intentIntegration,
     existingSlugs,
     prefill,
     fixedSlug,
         clientId: clientId.trim(),
         clientSecret: clientSecret.trim(),
         resource,
-        // Editing keeps the app's original origin; only a fresh registration
+        // Editing preserves the app's already-recorded origin (via
-        // from an integration's dialog stamps recorded intent.
+        // `intentIntegration`, passed verbatim by the caller); a fresh
-        originIntegration: fixedSlug ? null : (integrationSlug ?? null),
+        // registration from an integration's dialog stamps recorded intent.
+        originIntegration: resolveOriginIntegration(intentIntegration, integrationSlug),
       },
       reactivityKeys: oauthClientWriteKeys,
     });