Merge remote-tracking branch 'origin/codex/batch18-openapi-boundaries' into codex/effect-lint-integration

# Conflicts: # packages/plugins/openapi/src/react/AddOpenApiSource.tsx # packages/plugins/openapi/src/react/EditOpenApiSource.tsx

Rhys Sullivan committed 6 months ago

Commit 7257c892 parents 3f7841a 9494cb43 files · +407 −401Browse files

Unified · Split

3 files

packages/plugins/openapi/src/react/AddOpenApiSource.tsx +82 −100
packages/plugins/openapi/src/react/EditOpenApiSource.tsx +82 −91
packages/plugins/openapi/src/sdk/store.ts +243 −210

packages/plugins/openapi/src/react/AddOpenApiSource.tsx+82−100

@@ -1,6 +1,8 @@
1	1	import { useCallback, useEffect, useRef, useState } from "react";
2	2	import { useAtomSet } from "@effect/atom-react";
3		−import { Effect, Exit, Option, Schema } from "effect";
	3	+import * as Exit from "effect/Exit";
	4	+import * as Option from "effect/Option";
	5	+import * as Schema from "effect/Schema";
4	6
5	7	import { ConnectionId, ScopeId, SecretId } from "@executor-js/sdk/core";
6	8	import { startOAuth } from "@executor-js/react/api/atoms";
@@ -81,33 +83,19 @@ import { · 74 unmodified lines
81	83	type ServerVariable,
82	84	} from "../sdk/types";
83	85
84		−export const OPENAPI_OAUTH_POPUP_NAME = "openapi-oauth";
85		−export const OPENAPI_OAUTH_CALLBACK_PATH = "/api/oauth/callback";
86		−const PublicErrorMessage = Schema.Struct({
87		− _tag: Schema.Literals(["OpenApiParseError", "OpenApiExtractionError", "OpenApiOAuthError"]),
88		− message: Schema.String,
89		−});
90		−
91		−const messageFromExit = (exit: Exit.Exit<unknown, unknown>, fallback: string): string => {
92		− const error = Exit.findErrorOption(exit);
93		− if (Option.isNone(error)) return fallback;
94		− const errorMessage = Schema.decodeUnknownOption(PublicErrorMessage)(error.value);
95		− return Option.match(errorMessage, {
96		− onNone: () => fallback,
97		− onSome: (value) => value.message,
98		− });
99		−};
	86	+const ErrorMessage = Schema.Struct({ message: Schema.String });
100	87
101		−const failPromise = <A,>(message: string): Promise<A> => Effect.runPromise(Effect.fail(message));
	88	+const errorMessageFromExit = (exit: Exit.Exit<unknown, unknown>, fallback: string): string =>
	89	+ Option.match(
	90	+ Option.flatMap(Exit.findErrorOption(exit), Schema.decodeUnknownOption(ErrorMessage)),
	91	+ {
	92	+ onNone: () => fallback,
	93	+ onSome: ({ message }) => message,
	94	+ },
	95	+ );
102	96
103		−const parseUrlOption = (url: string, baseUrl?: string): URL \| null => {
104		− // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: URL constructor is the platform URL parser
105		− try {
106		− return baseUrl === undefined ? new URL(url) : new URL(url, baseUrl);
107		− } catch {
108		− return null;
109		− }
110		−};
	97	+export const OPENAPI_OAUTH_POPUP_NAME = "openapi-oauth";
	98	+export const OPENAPI_OAUTH_CALLBACK_PATH = "/api/oauth/callback";
111	99
112	100	const substituteUrlVariables = (url: string, values: Record<string, string>): string => {
113	101	let out = url;
@@ -134,15 +122,15 @@ export const openApiOAuthConnectionId = ( · 20 unmodified lines
134	122	*/
135	123	export function resolveOAuthUrl(url: string, baseUrl: string): string {
136	124	if (!url) return url;
137		− if (parseUrlOption(url)) {
	125	+ if (URL.canParse(url)) {
138	126	return url;
139	127	}
140		− if (!baseUrl) return url;
141		− return parseUrlOption(url, baseUrl)?.toString() ?? url;
	128	+ if (!baseUrl \|\| !URL.canParse(url, baseUrl)) return url;
	129	+ return new URL(url, baseUrl).toString();
142	130	}
143	131
144	132	export function inferOAuthIssuerUrl(authorizationUrl: string): string \| null {
145		− return parseUrlOption(authorizationUrl)?.origin ?? null;
	133	+ return URL.canParse(authorizationUrl) ? new URL(authorizationUrl).origin : null;
146	134	}
147	135
148	136	type StrategySelection =
@@ -293,7 +281,7 @@ export default function AddOpenApiSource(props: { · 144 unmodified lines
293	281	selectedServerIndex >= 0 ? (servers[selectedServerIndex] ?? null) : null;
294	282
295	283	const serverVariables: Record<string, ServerVariable> = selectedServer
296		− ? Option.getOrElse(selectedServer.variables, () => ({}) as Record<string, ServerVariable>)
	284	+ ? Option.getOrElse(selectedServer.variables, () => ({}))
297	285	: {};
298	286	const serverVariableEntries: Array<[string, ServerVariable]> = Object.entries(serverVariables);
299	287
@@ -305,10 +293,7 @@ export default function AddOpenApiSource(props: { · 5 unmodified lines
305	293	// Helper used by analyze + server selection: build a default selection map
306	294	// from a server's variable defaults.
307	295	const defaultSelectionsFor = (server: ServerInfo): Record<string, string> => {
308		− const vars: Record<string, ServerVariable> = Option.getOrElse(
309		− server.variables,
310		− () => ({}) as Record<string, ServerVariable>,
311		− );
	296	+ const vars: Record<string, ServerVariable> = Option.getOrElse(server.variables, () => ({}));
312	297	const out: Record<string, string> = {};
313	298	for (const [name, v] of Object.entries(vars)) out[name] = v.default;
314	299	return out;
@@ -387,19 +372,20 @@ export default function AddOpenApiSource(props: { · 72 unmodified lines
387	372	setAnalyzeError(null);
388	373	setAddError(null);
389	374	const credentials = serializeHttpCredentials(specFetchCredentials);
390		− const previewExit = await doPreview({
	375	+ const exit = await doPreview({
391	376	params: { scopeId },
392	377	payload: {
393	378	spec: specUrl,
394	379	specFetchCredentials: credentials,
395	380	},
396	381	});
397		− if (Exit.isFailure(previewExit)) {
398		− setAnalyzeError(messageFromExit(previewExit, "Failed to parse spec"));
	382	+ if (Exit.isFailure(exit)) {
	383	+ setAnalyzeError(errorMessageFromExit(exit, "Failed to parse spec"));
399	384	setAnalyzing(false);
400	385	return;
401	386	}
402		− const result = previewExit.value;
	387	+
	388	+ const result = exit.value;
403	389	setPreview(result);
404	390
405	391	const firstServer = result.servers[0];
@@ -500,7 +486,7 @@ export default function AddOpenApiSource(props: { · 94 unmodified lines
500	486	}
501	487	setStartingOAuth(true);
502	488	const connectionId = openApiOAuthConnectionId(resolvedSourceId, selectedOAuth2Preset.flow);
503		− const startExit = await doStartOAuth({
	489	+ const startOAuthExit = await doStartOAuth({
504	490	params: { scopeId },
505	491	payload: {
506	492	endpoint: tokenUrl,
@@ -519,11 +505,11 @@ export default function AddOpenApiSource(props: { · 12 unmodified lines
519	505	},
520	506	});
521	507	setStartingOAuth(false);
522		− if (Exit.isFailure(startExit)) {
523		− setOauth2Error(messageFromExit(startExit, "Failed to start OAuth"));
	508	+ if (Exit.isFailure(startOAuthExit)) {
	509	+ setOauth2Error(errorMessageFromExit(startOAuthExit, "Failed to start OAuth"));
524	510	return;
525	511	}
526		− const response = startExit.value;
	512	+ const response = startOAuthExit.value;
527	513	if (!response.completedConnection) {
528	514	setOauth2Error("client_credentials flow did not mint a connection");
529	515	return;
@@ -551,41 +537,41 @@ export default function AddOpenApiSource(props: { · 21 unmodified lines
551	537	resolvedBaseUrl,
552	538	);
553	539	const issuerUrl = inferOAuthIssuerUrl(authorizationUrl);
	540	+ const startOAuthExit = await doStartOAuth({
	541	+ params: { scopeId },
	542	+ payload: {
	543	+ endpoint: authorizationUrl,
	544	+ connectionId: openApiOAuthConnectionId(resolvedSourceId, selectedOAuth2Preset.flow),
	545	+ tokenScope: scopeId,
	546	+ redirectUrl: oauth2RedirectUrl,
	547	+ strategy: {
	548	+ kind: "authorization-code",
	549	+ authorizationEndpoint: authorizationUrl,
	550	+ tokenEndpoint: tokenUrl,
	551	+ issuerUrl,
	552	+ clientIdSecretId: oauth2ClientIdSecretId,
	553	+ clientSecretSecretId: oauth2ClientSecretSecretId ?? null,
	554	+ scopes: [...oauth2SelectedScopes],
	555	+ },
	556	+ pluginId: "openapi",
	557	+ identityLabel: `${displayName} OAuth`,
	558	+ },
	559	+ });
	560	+ if (Exit.isFailure(startOAuthExit)) {
	561	+ setOauth2Error(errorMessageFromExit(startOAuthExit, "Failed to start OAuth"));
	562	+ return;
	563	+ }
	564	+ const response = startOAuthExit.value;
	565	+ if (response.authorizationUrl === null) {
	566	+ setOauth2Error("Unexpected response flow from server");
	567	+ return;
	568	+ }
554	569
555	570	await oauth.openAuthorization({
556		− run: async () => {
557		− const startExit = await doStartOAuth({
558		− params: { scopeId },
559		− payload: {
560		− endpoint: authorizationUrl,
561		− connectionId: openApiOAuthConnectionId(resolvedSourceId, selectedOAuth2Preset.flow),
562		− tokenScope: scopeId,
563		− redirectUrl: oauth2RedirectUrl,
564		− strategy: {
565		− kind: "authorization-code",
566		− authorizationEndpoint: authorizationUrl,
567		− tokenEndpoint: tokenUrl,
568		− issuerUrl,
569		− clientIdSecretId: oauth2ClientIdSecretId,
570		− clientSecretSecretId: oauth2ClientSecretSecretId ?? null,
571		− scopes: [...oauth2SelectedScopes],
572		− },
573		− pluginId: "openapi",
574		− identityLabel: `${displayName} OAuth`,
575		− },
576		− });
577		− if (Exit.isFailure(startExit)) {
578		− return failPromise(messageFromExit(startExit, "Failed to start OAuth"));
579		− }
580		− const response = startExit.value;
581		− if (response.authorizationUrl === null) {
582		− return failPromise("Unexpected response flow from server");
583		− }
584		− return {
585		− sessionId: response.sessionId,
586		− authorizationUrl: response.authorizationUrl,
587		− };
588		− },
	571	+ run: async () => ({
	572	+ sessionId: response.sessionId,
	573	+ authorizationUrl: response.authorizationUrl,
	574	+ }),
589	575	onSuccess: (result) => {
590	576	setOauth2AuthState({
591	577	fingerprint: selectedOAuth2Fingerprint,
@@ -641,7 +627,12 @@ export default function AddOpenApiSource(props: { · 49 unmodified lines
641	627	kind: "openapi",
642	628	url: resolvedBaseUrl \|\| undefined,
643	629	});
644		− const addExit = await doAdd({
	630	+ const failAdd = (message: string) => {
	631	+ setAddError(message);
	632	+ setAdding(false);
	633	+ placeholder.done();
	634	+ };
	635	+ const resultExit = await doAdd({
645	636	params: { scopeId },
646	637	payload: {
647	638	spec: specUrl,
@@ -657,14 +648,13 @@ export default function AddOpenApiSource(props: { · 9 unmodified lines
657	648	},
658	649	reactivityKeys: addSpecWriteKeys,
659	650	});
660		− if (Exit.isFailure(addExit)) {
661		− placeholder.done();
662		− setAddError(messageFromExit(addExit, "Failed to add source"));
663		− setAdding(false);
	651	+
	652	+ if (Exit.isFailure(resultExit)) {
	653	+ failAdd(errorMessageFromExit(resultExit, "Failed to add source"));
664	654	return;
665	655	}
666	656
667		− const sourceId = addExit.value.namespace;
	657	+ const sourceId = resultExit.value.namespace;
668	658	const sourceScope = ScopeId.make(scopeId);
669	659	const bindingScope = ScopeId.make(userScope);
670	660
@@ -684,15 +674,13 @@ export default function AddOpenApiSource(props: { · 13 unmodified lines
684	674	reactivityKeys: bindingWriteKeys,
685	675	});
686	676	if (Exit.isFailure(bindingExit)) {
687		− placeholder.done();
688		− setAddError(messageFromExit(bindingExit, "Failed to add source"));
689		− setAdding(false);
	677	+ failAdd(errorMessageFromExit(bindingExit, "Failed to add source"));
690	678	return;
691	679	}
692	680	}
693	681
694	682	if (configuredOAuth2 && oauth2ClientIdSecretId) {
695		− const bindingExit = await doSetBinding({
	683	+ const clientIdBindingExit = await doSetBinding({
696	684	params: { scopeId },
697	685	payload: {
698	686	sourceId,
@@ -706,16 +694,14 @@ export default function AddOpenApiSource(props: { · 7 unmodified lines
706	694	},
707	695	reactivityKeys: bindingWriteKeys,
708	696	});
709		− if (Exit.isFailure(bindingExit)) {
710		− placeholder.done();
711		− setAddError(messageFromExit(bindingExit, "Failed to add source"));
712		− setAdding(false);
	697	+ if (Exit.isFailure(clientIdBindingExit)) {
	698	+ failAdd(errorMessageFromExit(clientIdBindingExit, "Failed to add source"));
713	699	return;
714	700	}
715	701	}
716	702
717	703	if (configuredOAuth2?.clientSecretSlot && oauth2ClientSecretSecretId) {
718		− const bindingExit = await doSetBinding({
	704	+ const clientSecretBindingExit = await doSetBinding({
719	705	params: { scopeId },
720	706	payload: {
721	707	sourceId,
@@ -729,16 +715,14 @@ export default function AddOpenApiSource(props: { · 7 unmodified lines
729	715	},
730	716	reactivityKeys: bindingWriteKeys,
731	717	});
732		− if (Exit.isFailure(bindingExit)) {
733		− placeholder.done();
734		− setAddError(messageFromExit(bindingExit, "Failed to add source"));
735		− setAdding(false);
	718	+ if (Exit.isFailure(clientSecretBindingExit)) {
	719	+ failAdd(errorMessageFromExit(clientSecretBindingExit, "Failed to add source"));
736	720	return;
737	721	}
738	722	}
739	723
740	724	if (configuredOAuth2 && oauth2Auth) {
741		− const bindingExit = await doSetBinding({
	725	+ const connectionBindingExit = await doSetBinding({
742	726	params: { scopeId },
743	727	payload: {
744	728	sourceId,
@@ -752,10 +736,8 @@ export default function AddOpenApiSource(props: { · 7 unmodified lines
752	736	},
753	737	reactivityKeys: bindingWriteKeys,
754	738	});
755		− if (Exit.isFailure(bindingExit)) {
756		− placeholder.done();
757		− setAddError(messageFromExit(bindingExit, "Failed to add source"));
758		− setAdding(false);
	739	+ if (Exit.isFailure(connectionBindingExit)) {
	740	+ failAdd(errorMessageFromExit(connectionBindingExit, "Failed to add source"));
759	741	return;
760	742	}
761	743	}

packages/plugins/openapi/src/react/EditOpenApiSource.tsx+82−91

@@ -1,6 +1,8 @@
1	1	import { useEffect, useMemo, useRef, useState } from "react";
2	2	import { useAtomSet, useAtomValue } from "@effect/atom-react";
3		−import { Effect, Exit, Option, Schema } from "effect";
	3	+import * as Exit from "effect/Exit";
	4	+import * as Option from "effect/Option";
	5	+import * as Schema from "effect/Schema";
4	6	import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
5	7
6	8	import { connectionsAtom, sourceAtom, startOAuth } from "@executor-js/react/api/atoms";
@@ -43,7 +45,21 @@ import { · 36 unmodified lines
43	45	resolveOAuthUrl,
44	46	} from "./AddOpenApiSource";
45	47	import { oauth2ClientSecretSlot } from "../sdk/store";
46		−import type { OpenApiSourceBindingValue } from "../sdk/types";
	48	+import {
	49	+ OpenApiSourceBindingValue,
	50	+ type OpenApiSourceBindingValue as OpenApiSourceBindingValueType,
	51	+} from "../sdk/types";
	52	+
	53	+const ErrorMessage = Schema.Struct({ message: Schema.String });
	54	+
	55	+const errorMessageFromExit = (exit: Exit.Exit<unknown, unknown>, fallback: string): string =>
	56	+ Option.match(
	57	+ Option.flatMap(Exit.findErrorOption(exit), Schema.decodeUnknownOption(ErrorMessage)),
	58	+ {
	59	+ onNone: () => fallback,
	60	+ onSome: ({ message }) => message,
	61	+ },
	62	+ );
47	63
48	64	type SlotDef =
49	65	\| {
@@ -86,31 +102,6 @@ const openApiOAuthConnectionId = ( · 36 unmodified lines
86	102	const bindingSecretId = (sourceId: string, slot: string, scopeId: string): string =>
87	103	`source-binding-${slugify(sourceId)}-${slugify(slot)}-${slugify(scopeId)}`;
88	104
89		−const PublicErrorMessage = Schema.Struct({
90		− _tag: Schema.Literals(["OpenApiParseError", "OpenApiExtractionError", "OpenApiOAuthError"]),
91		− message: Schema.String,
92		−});
93		−const SecretBindingValue = Schema.Struct({
94		− kind: Schema.Literal("secret"),
95		− secretId: Schema.String,
96		−});
97		−const ConnectionBindingValue = Schema.Struct({
98		− kind: Schema.Literal("connection"),
99		− connectionId: Schema.String,
100		−});
101		−
102		−const messageFromExit = (exit: Exit.Exit<unknown, unknown>, fallback: string): string => {
103		− const error = Exit.findErrorOption(exit);
104		− if (Option.isNone(error)) return fallback;
105		− const errorMessage = Schema.decodeUnknownOption(PublicErrorMessage)(error.value);
106		− return Option.match(errorMessage, {
107		− onNone: () => fallback,
108		− onSome: (value) => value.message,
109		− });
110		−};
111		−
112		−const failPromise = <A,>(message: string): Promise<A> => Effect.runPromise(Effect.fail(message));
113		−
114	105	const effectiveClientSecretSlot = (oauth2: {
115	106	readonly securitySchemeName: string;
116	107	readonly clientSecretSlot: string \| null;
@@ -145,13 +136,13 @@ const effectiveBindingForScope = ( · 28 unmodified lines
145	136
146	137	const isSecretBindingValue = (
147	138	value: unknown,
148		−): value is Extract<OpenApiSourceBindingValue, { readonly kind: "secret" }> =>
149		− Option.isSome(Schema.decodeUnknownOption(SecretBindingValue)(value));
	139	+): value is Extract<OpenApiSourceBindingValueType, { readonly kind: "secret" }> =>
	140	+ Schema.is(OpenApiSourceBindingValue)(value) && value.kind === "secret";
150	141
151	142	const isConnectionBindingValue = (
152	143	value: unknown,
153		−): value is Extract<OpenApiSourceBindingValue, { readonly kind: "connection" }> =>
154		− Option.isSome(Schema.decodeUnknownOption(ConnectionBindingValue)(value));
	144	+): value is Extract<OpenApiSourceBindingValueType, { readonly kind: "connection" }> =>
	145	+ Schema.is(OpenApiSourceBindingValue)(value) && value.kind === "connection";
155	146
156	147	export default function EditOpenApiSource(props: {
157	148	readonly sourceId: string;
@@ -253,13 +244,12 @@ export default function EditOpenApiSource(props: { · 95 unmodified lines
253	244	},
254	245	reactivityKeys: openApiWriteKeys,
255	246	});
	247	+ if (sourceSaveSeq.current !== seq) return;
256	248	if (Exit.isFailure(exit)) {
257		− if (sourceSaveSeq.current !== seq) return;
258	249	setSourceSaveState("idle");
259		− setError(messageFromExit(exit, "Failed to save source details"));
	250	+ setError(errorMessageFromExit(exit, "Failed to save source details"));
260	251	return;
261	252	}
262		− if (sourceSaveSeq.current !== seq) return;
263	253	setSourceSaveState("saved");
264	254	window.setTimeout(() => {
265	255	if (sourceSaveSeq.current === seq) setSourceSaveState("idle");
@@ -352,7 +342,7 @@ export default function EditOpenApiSource(props: { · 86 unmodified lines
352	342	reactivityKeys: sourceWriteKeys,
353	343	});
354	344	if (Exit.isFailure(exit)) {
355		− setError(messageFromExit(exit, "Failed to save credential binding"));
	345	+ setError(errorMessageFromExit(exit, "Failed to save credential binding"));
356	346	}
357	347	setBusyKey(null);
358	348	};
@@ -371,7 +361,7 @@ export default function EditOpenApiSource(props: { · 12 unmodified lines
371	361	reactivityKeys: sourceWriteKeys,
372	362	});
373	363	if (Exit.isFailure(exit)) {
374		− setError(messageFromExit(exit, "Failed to clear credential binding"));
	364	+ setError(errorMessageFromExit(exit, "Failed to clear credential binding"));
375	365	}
376	366	setBusyKey(null);
377	367	};
@@ -425,18 +415,23 @@ export default function EditOpenApiSource(props: { · 47 unmodified lines
425	415	setPendingOAuthConnection({
426	416	scopeId: targetScope,
427	417	slot: oauth2.connectionSlot,
428		− connectionId,
	418	+ connectionId: connectionId,
429	419	});
430	420	setError(null);
	421	+ const failConnect = (message: string) => {
	422	+ setError(message);
	423	+ setPendingOAuthConnection(null);
	424	+ setBusyKey(null);
	425	+ };
431	426	const displayName = source.name;
432	427	const tokenUrl = resolveOAuthUrl(oauth2.tokenUrl, source.config.baseUrl ?? "");
433	428	if (oauth2.flow === "clientCredentials") {
434		− const startExit = await doStartOAuth({
	429	+ const startOAuthExit = await doStartOAuth({
435	430	params: { scopeId: displayScope },
436	431	payload: {
437	432	endpoint: tokenUrl,
438	433	redirectUrl: tokenUrl,
439		− connectionId,
	434	+ connectionId: connectionId,
440	435	tokenScope: targetScope,
441	436	strategy: {
442	437	kind: "client-credentials",
@@ -449,20 +444,16 @@ export default function EditOpenApiSource(props: { · 6 unmodified lines
449	444	identityLabel: `${displayName} OAuth`,
450	445	},
451	446	});
452		− if (Exit.isFailure(startExit)) {
453		− setError(messageFromExit(startExit, "Failed to connect OAuth"));
454		− setPendingOAuthConnection(null);
455		− setBusyKey(null);
	447	+ if (Exit.isFailure(startOAuthExit)) {
	448	+ failConnect(errorMessageFromExit(startOAuthExit, "Failed to connect OAuth"));
456	449	return;
457	450	}
458		− const response = startExit.value;
	451	+ const response = startOAuthExit.value;
459	452	if (!response.completedConnection) {
460		− setError("Unexpected OAuth response");
461		− setPendingOAuthConnection(null);
462		− setBusyKey(null);
	453	+ failConnect("Unexpected OAuth response");
463	454	return;
464	455	}
465		− const bindingExit = await doSetBinding({
	456	+ const setBindingExit = await doSetBinding({
466	457	params: { scopeId: displayScope },
467	458	payload: {
468	459	sourceId: props.sourceId,
@@ -476,8 +467,9 @@ export default function EditOpenApiSource(props: { · 7 unmodified lines
476	467	},
477	468	reactivityKeys: [...sourceWriteKeys, ...connectionWriteKeys],
478	469	});
479		− if (Exit.isFailure(bindingExit)) {
480		− setError(messageFromExit(bindingExit, "Failed to connect OAuth"));
	470	+ if (Exit.isFailure(setBindingExit)) {
	471	+ failConnect(errorMessageFromExit(setBindingExit, "Failed to connect OAuth"));
	472	+ return;
481	473	}
482	474	setPendingOAuthConnection(null);
483	475	setBusyKey(null);
@@ -489,45 +481,46 @@ export default function EditOpenApiSource(props: { · 5 unmodified lines
489	481	source.config.baseUrl ?? "",
490	482	);
491	483	const issuerUrl = oauth2.issuerUrl ?? inferOAuthIssuerUrl(authorizationUrl);
492		− await oauth.openAuthorization({
493		− run: async () => {
494		− const startExit = await doStartOAuth({
495		− params: { scopeId: displayScope },
496		− payload: {
497		− endpoint: authorizationUrl,
498		− connectionId,
499		− tokenScope: targetScope,
500		− redirectUrl: oauth2RedirectUrl,
501		− strategy: {
502		− kind: "authorization-code",
503		− authorizationEndpoint: authorizationUrl,
504		− tokenEndpoint: tokenUrl,
505		− issuerUrl,
506		− clientIdSecretId,
507		− clientSecretSecretId:
508		− clientSecretBinding && isSecretBindingValue(clientSecretBinding.value)
509		− ? clientSecretBinding.value.secretId
510		− : null,
511		− scopes: [...oauth2.scopes],
512		− },
513		− pluginId: "openapi",
514		− identityLabel: `${displayName} OAuth`,
515		− },
516		− });
517		− if (Exit.isFailure(startExit)) {
518		− return failPromise(messageFromExit(startExit, "Failed to connect OAuth"));
519		− }
520		− const response = startExit.value;
521		− if (response.authorizationUrl === null) {
522		− return failPromise("Unexpected OAuth response");
523		− }
524		− return {
525		− sessionId: response.sessionId,
526		− authorizationUrl: response.authorizationUrl,
527		− };
	484	+ const startOAuthExit = await doStartOAuth({
	485	+ params: { scopeId: displayScope },
	486	+ payload: {
	487	+ endpoint: authorizationUrl,
	488	+ connectionId,
	489	+ tokenScope: targetScope,
	490	+ redirectUrl: oauth2RedirectUrl,
	491	+ strategy: {
	492	+ kind: "authorization-code",
	493	+ authorizationEndpoint: authorizationUrl,
	494	+ tokenEndpoint: tokenUrl,
	495	+ issuerUrl,
	496	+ clientIdSecretId,
	497	+ clientSecretSecretId:
	498	+ clientSecretBinding && isSecretBindingValue(clientSecretBinding.value)
	499	+ ? clientSecretBinding.value.secretId
	500	+ : null,
	501	+ scopes: [...oauth2.scopes],
	502	+ },
	503	+ pluginId: "openapi",
	504	+ identityLabel: `${displayName} OAuth`,
528	505	},
	506	+ });
	507	+ if (Exit.isFailure(startOAuthExit)) {
	508	+ failConnect(errorMessageFromExit(startOAuthExit, "Failed to connect OAuth"));
	509	+ return;
	510	+ }
	511	+ const response = startOAuthExit.value;
	512	+ if (response.authorizationUrl === null) {
	513	+ failConnect("Unexpected OAuth response");
	514	+ return;
	515	+ }
	516	+
	517	+ await oauth.openAuthorization({
	518	+ run: async () => ({
	519	+ sessionId: response.sessionId,
	520	+ authorizationUrl: response.authorizationUrl,
	521	+ }),
529	522	onSuccess: async (result) => {
530		− const bindingExit = await doSetBinding({
	523	+ const setBindingExit = await doSetBinding({
531	524	params: { scopeId: displayScope },
532	525	payload: {
533	526	sourceId: props.sourceId,
@@ -541,10 +534,8 @@ export default function EditOpenApiSource(props: { · 7 unmodified lines
541	534	},
542	535	reactivityKeys: [...sourceWriteKeys, ...connectionWriteKeys],
543	536	});
544		− if (Exit.isFailure(bindingExit)) {
545		− setError(messageFromExit(bindingExit, "Failed to connect OAuth"));
546		− setPendingOAuthConnection(null);
547		− setBusyKey(null);
	537	+ if (Exit.isFailure(setBindingExit)) {
	538	+ failConnect(errorMessageFromExit(setBindingExit, "Failed to connect OAuth"));
548	539	return;
549	540	}
550	541	setPendingOAuthConnection(null);

packages/plugins/openapi/src/sdk/store.ts+243−210

@@ -1,4 +1,4 @@
1		−import { Effect, Schema } from "effect";
	1	+import { Effect, Option, Schema } from "effect";
2	2
3	3	import {
4	4	ConnectionId,
@@ -174,9 +174,7 @@ export interface StoredSource { · 169 unmodified lines
174	174	// an encodable/decodable shape for HTTP responses.
175	175	// ---------------------------------------------------------------------------
176	176
177		−export class StoredSourceSchema extends Schema.Class<StoredSourceSchema>(
178		− "OpenApiStoredSource",
179		−)({
	177	+export class StoredSourceSchema extends Schema.Class<StoredSourceSchema>("OpenApiStoredSource")({
180	178	namespace: Schema.String,
181	179	name: Schema.String,
182	180	config: Schema.Struct({
@@ -184,20 +182,12 @@ export class StoredSourceSchema extends Schema.Class<StoredSourceSchema>( · 1 unmodified line
184	182	sourceUrl: Schema.optional(Schema.String),
185	183	baseUrl: Schema.optional(Schema.String),
186	184	namespace: Schema.optional(Schema.String),
187		− headers: Schema.optional(
188		− Schema.Record(Schema.String, ConfiguredHeaderValue),
189		− ),
190		− queryParams: Schema.optional(
191		− Schema.Record(Schema.String, HeaderValue),
192		− ),
	185	+ headers: Schema.optional(Schema.Record(Schema.String, ConfiguredHeaderValue)),
	186	+ queryParams: Schema.optional(Schema.Record(Schema.String, HeaderValue)),
193	187	specFetchCredentials: Schema.optional(
194	188	Schema.Struct({
195		− headers: Schema.optional(
196		− Schema.Record(Schema.String, HeaderValue),
197		− ),
198		− queryParams: Schema.optional(
199		− Schema.Record(Schema.String, HeaderValue),
200		− ),
	189	+ headers: Schema.optional(Schema.Record(Schema.String, HeaderValue)),
	190	+ queryParams: Schema.optional(Schema.Record(Schema.String, HeaderValue)),
201	191	}),
202	192	),
203	193	// Canonical source-owned OAuth config. Concrete client credentials
@@ -221,10 +211,85 @@ export interface StoredOperation { · 17 unmodified lines
221	211
222	212	const encodeBinding = Schema.encodeSync(OperationBinding);
223	213	const decodeBinding = Schema.decodeUnknownSync(OperationBinding);
	214	+const decodeBindingJson = Schema.decodeUnknownSync(Schema.fromJsonString(OperationBinding));
224	215
225	216	const decodeOAuth2 = Schema.decodeUnknownSync(OAuth2Auth);
	217	+const decodeOAuth2Option = Schema.decodeUnknownOption(OAuth2Auth);
	218	+const decodeOAuth2JsonOption = Schema.decodeUnknownOption(Schema.fromJsonString(OAuth2Auth));
	219	+const decodeOAuth2SourceConfigOption = Schema.decodeUnknownOption(OAuth2SourceConfig);
	220	+const decodeOAuth2SourceConfigJsonOption = Schema.decodeUnknownOption(
	221	+ Schema.fromJsonString(OAuth2SourceConfig),
	222	+);
226	223	const encodeOAuth2SourceConfig = Schema.encodeSync(OAuth2SourceConfig);
227	224
	225	+const decodeHeaderValueOption = Schema.decodeUnknownOption(HeaderValue);
	226	+const UnknownRecord = Schema.Record(Schema.String, Schema.Unknown);
	227	+const decodeUnknownRecord = Schema.decodeUnknownSync(UnknownRecord);
	228	+const decodeUnknownRecordJson = Schema.decodeUnknownSync(Schema.fromJsonString(UnknownRecord));
	229	+const decodeConfiguredHeaderBindingOption = Schema.decodeUnknownOption(ConfiguredHeaderBinding);
	230	+
	231	+const NullableString = Schema.NullOr(Schema.String);
	232	+const OptionalNullableString = Schema.optional(NullableString);
	233	+
	234	+const ChildStorageRow = Schema.Struct({
	235	+ name: Schema.String,
	236	+ kind: Schema.Literals(["text", "secret"]),
	237	+ text_value: OptionalNullableString,
	238	+ secret_id: OptionalNullableString,
	239	+ secret_prefix: OptionalNullableString,
	240	+});
	241	+const decodeChildStorageRowOption = Schema.decodeUnknownOption(ChildStorageRow);
	242	+
	243	+const SourceBindingStorageRow = Schema.Struct({
	244	+ source_id: Schema.String,
	245	+ source_scope_id: Schema.String,
	246	+ target_scope_id: Schema.String,
	247	+ slot: Schema.String,
	248	+ kind: Schema.Literals(["secret", "connection", "text"]),
	249	+ secret_id: OptionalNullableString,
	250	+ connection_id: OptionalNullableString,
	251	+ text_value: OptionalNullableString,
	252	+ created_at: Schema.Unknown,
	253	+ updated_at: Schema.Unknown,
	254	+});
	255	+const decodeSourceBindingStorageRow = Schema.decodeUnknownSync(SourceBindingStorageRow);
	256	+
	257	+const SourceStorageRow = Schema.Struct({
	258	+ id: Schema.String,
	259	+ scope_id: Schema.String,
	260	+ name: Schema.String,
	261	+ spec: Schema.String,
	262	+ source_url: OptionalNullableString,
	263	+ base_url: OptionalNullableString,
	264	+ headers: Schema.optional(Schema.Unknown),
	265	+ oauth2: Schema.optional(Schema.Unknown),
	266	+});
	267	+const decodeSourceStorageRow = Schema.decodeUnknownSync(SourceStorageRow);
	268	+
	269	+const OperationStorageRow = Schema.Struct({
	270	+ id: Schema.String,
	271	+ source_id: Schema.String,
	272	+ binding: Schema.Unknown,
	273	+});
	274	+const decodeOperationStorageRow = Schema.decodeUnknownSync(OperationStorageRow);
	275	+
	276	+const ChildUsageStorageRow = Schema.Struct({
	277	+ source_id: Schema.String,
	278	+ scope_id: Schema.String,
	279	+ name: Schema.String,
	280	+});
	281	+const decodeChildUsageStorageRow = Schema.decodeUnknownSync(ChildUsageStorageRow);
	282	+
	283	+const SourceNameStorageRow = Schema.Struct({
	284	+ id: Schema.String,
	285	+ scope_id: Schema.String,
	286	+ name: Schema.String,
	287	+});
	288	+const decodeSourceNameStorageRow = Schema.decodeUnknownSync(SourceNameStorageRow);
	289	+
	290	+const decodeStorageDate = (value: unknown): Date =>
	291	+ value instanceof Date ? value : new Date(Schema.decodeUnknownSync(Schema.String)(value));
	292	+
228	293	interface ChildRow {
229	294	readonly id: string;
230	295	readonly scope_id: string;
@@ -277,21 +342,24 @@ const childRowsToValueMap = ( · 46 unmodified lines
277	342	): Record<string, HeaderValue> => {
278	343	const out: Record<string, HeaderValue> = {};
279	344	for (const row of rows) {
280		− const name = row.name as string;
281		− if (row.kind === "secret" && typeof row.secret_id === "string") {
282		− const prefix = row.secret_prefix as string \| undefined \| null;
283		− out[name] = prefix
284		− ? { secretId: row.secret_id, prefix }
285		− : { secretId: row.secret_id };
286		− } else if (row.kind === "text" && typeof row.text_value === "string") {
287		− out[name] = row.text_value;
	345	+ const decoded = decodeChildStorageRowOption(row);
	346	+ if (Option.isSome(decoded)) {
	347	+ const child = decoded.value;
	348	+ if (child.kind === "secret" && child.secret_id != null) {
	349	+ out[child.name] =
	350	+ child.secret_prefix != null
	351	+ ? { secretId: child.secret_id, prefix: child.secret_prefix }
	352	+ : { secretId: child.secret_id };
	353	+ } else if (child.kind === "text" && child.text_value != null) {
	354	+ out[child.name] = child.text_value;
	355	+ }
288	356	}
289	357	}
290	358	return out;
291	359	};
292	360
293		−const toJsonRecord = (value: unknown): Record<string, unknown> =>
294		− value as Record<string, unknown>;
	361	+// oxlint-disable-next-line executor/no-explicit-unknown-record -- boundary: storage adapter accepts JSON object columns
	362	+const toJsonRecord = (value: unknown): Record<string, unknown> => value as Record<string, unknown>;
295	363
296	364	const toConfiguredHeaderBinding = (value: {
297	365	readonly slot?: unknown;
@@ -303,11 +371,10 @@ const toConfiguredHeaderBinding = (value: { · 5 unmodified lines
303	371	...(typeof value.prefix === "string" ? { prefix: value.prefix } : {}),
304	372	});
305	373
306		−const decodeHeaders = (value: unknown): Record<string, HeaderValue> => {
	374	+const decodeHeaders = (value: unknown): Record<string, unknown> => {
307	375	if (value == null) return {};
308		− if (typeof value === "string")
309		− return JSON.parse(value) as Record<string, HeaderValue>;
310		− return value as Record<string, HeaderValue>;
	376	+ if (typeof value === "string") return decodeUnknownRecordJson(value);
	377	+ return decodeUnknownRecord(value);
311	378	};
312	379
313	380	const slugifySlotPart = (value: string): string =>
@@ -344,20 +411,18 @@ const normalizeStoredHeaders = ( · 30 unmodified lines
344	411	legacy[name] = header;
345	412	continue;
346	413	}
347		− if (
348		− header &&
349		− typeof header === "object" &&
350		− "kind" in header &&
351		− (header as { kind?: unknown }).kind === "binding"
352		− ) {
353		− headers[name] = toConfiguredHeaderBinding(header);
	414	+ const binding = decodeConfiguredHeaderBindingOption(header);
	415	+ if (Option.isSome(binding)) {
	416	+ headers[name] = toConfiguredHeaderBinding(binding.value);
354	417	continue;
355	418	}
356		− legacy[name] = header;
	419	+ const legacyHeader = decodeHeaderValueOption(header);
	420	+ if (Option.isNone(legacyHeader)) continue;
	421	+ legacy[name] = legacyHeader.value;
357	422	headers[name] = new ConfiguredHeaderBinding({
358	423	kind: "binding",
359	424	slot: headerBindingSlot(name),
360		− prefix: header.prefix,
	425	+ prefix: typeof legacyHeader.value === "string" ? undefined : legacyHeader.value.prefix,
361	426	});
362	427	}
363	428	return { headers, legacy };
@@ -370,13 +435,16 @@ const normalizeStoredOAuth2 = ( · 6 unmodified lines
370	435	readonly legacy?: OAuth2Auth;
371	436	} => {
372	437	if (value == null) return {};
373		− const parsed = typeof value === "string" ? JSON.parse(value) : value;
374		− if (parsed && typeof parsed === "object" && "connectionSlot" in parsed) {
375		− return {
376		− oauth2: Schema.decodeUnknownSync(OAuth2SourceConfig)(parsed),
377		− };
	438	+ const sourceConfig =
	439	+ typeof value === "string"
	440	+ ? decodeOAuth2SourceConfigJsonOption(value)
	441	+ : decodeOAuth2SourceConfigOption(value);
	442	+ if (Option.isSome(sourceConfig)) {
	443	+ return { oauth2: sourceConfig.value };
378	444	}
379		− const legacy = decodeOAuth2(parsed);
	445	+ const legacyOption =
	446	+ typeof value === "string" ? decodeOAuth2JsonOption(value) : decodeOAuth2Option(value);
	447	+ const legacy = Option.isSome(legacyOption) ? legacyOption.value : decodeOAuth2(value);
380	448	return {
381	449	legacy,
382	450	oauth2: new OAuth2SourceConfig({
@@ -438,10 +506,7 @@ export interface OpenapiStore { · 55 unmodified lines
438	506	scope: string,
439	507	) => Effect.Effect<StoredSource \| null, StorageFailure>;
440	508
441		− readonly listSources: () => Effect.Effect<
442		− readonly StoredSource[],
443		− StorageFailure
444		− >;
	509	+ readonly listSources: () => Effect.Effect<readonly StoredSource[], StorageFailure>;
445	510
446	511	readonly getOperationByToolId: (
447	512	toolId: string,
@@ -453,10 +518,7 @@ export interface OpenapiStore { · 5 unmodified lines
453	518	scope: string,
454	519	) => Effect.Effect<readonly StoredOperation[], StorageFailure>;
455	520
456		− readonly removeSource: (
457		− namespace: string,
458		− scope: string,
459		− ) => Effect.Effect<void, StorageFailure>;
	521	+ readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
460	522
461	523	readonly listSourceBindings: (
462	524	sourceId: string,
@@ -501,10 +563,7 @@ export interface OpenapiStore { · 38 unmodified lines
501	563	* `query_param:foo` or `spec_fetch_header:Authorization`. */
502	564	readonly findChildRowsBySecret: (secretId: string) => Effect.Effect<
503	565	readonly {
504		− readonly kind:
505		− \| "query_param"
506		− \| "spec_fetch_header"
507		− \| "spec_fetch_query_param";
	566	+ readonly kind: "query_param" \| "spec_fetch_header" \| "spec_fetch_query_param";
508	567	readonly source_id: string;
509	568	readonly scope_id: string;
510	569	readonly name: string;
@@ -527,14 +586,12 @@ export const makeDefaultOpenapiStore = ({ · 16 unmodified lines
527	586	adapter,
528	587	scopes,
529	588	}: StorageDeps<OpenapiSchema>): OpenapiStore => {
530		− const scopeIds = scopes.map((scope) => scope.id as string);
	589	+ const scopeIds = scopes.map((scope) => String(scope.id));
531	590	const scopePrecedence = new Map<string, number>();
532	591	scopeIds.forEach((scope, index) => scopePrecedence.set(scope, index));
533		− const scopeRank = (scopeId: string): number =>
534		− scopePrecedence.get(scopeId) ?? Infinity;
	592	+ const scopeRank = (scopeId: string): number => scopePrecedence.get(scopeId) ?? Infinity;
535	593
536		− const encodeSyntheticRowIdPart = (value: string): string =>
537		− encodeURIComponent(value);
	594	+ const encodeSyntheticRowIdPart = (value: string): string => encodeURIComponent(value);
538	595
539	596	const sourceBindingRowId = (
540	597	sourceId: string,
@@ -550,47 +607,47 @@ export const makeDefaultOpenapiStore = ({ · 9 unmodified lines
550	607	encodeSyntheticRowIdPart(scopeId),
551	608	].join("::");
552	609
553		− const rowToSourceBindingValue = (
554		− row: Record<string, unknown>,
555		− ): OpenApiSourceBindingValue => {
556		− const kind = row.kind as string;
557		− if (kind === "secret" && typeof row.secret_id === "string") {
558		− return { kind: "secret", secretId: SecretId.make(row.secret_id) };
	610	+ const rowToSourceBindingValue = (row: Record<string, unknown>): OpenApiSourceBindingValue => {
	611	+ const decoded = decodeSourceBindingStorageRow(row);
	612	+ if (decoded.kind === "secret" && decoded.secret_id != null) {
	613	+ return { kind: "secret", secretId: SecretId.make(decoded.secret_id) };
559	614	}
560		− if (kind === "connection" && typeof row.connection_id === "string") {
	615	+ if (decoded.kind === "connection" && decoded.connection_id != null) {
561	616	return {
562	617	kind: "connection",
563		− connectionId: ConnectionId.make(row.connection_id),
	618	+ connectionId: ConnectionId.make(decoded.connection_id),
564	619	};
565	620	}
566	621	// text fallback covers both well-formed text rows and any
567	622	// partial/null row that survived a malformed write — `text_value`
568	623	// defaults to "" so the type stays satisfied without a throw.
569		− return { kind: "text", text: (row.text_value as string \| null) ?? "" };
	624	+ return { kind: "text", text: decoded.text_value ?? "" };
570	625	};
571	626
572		− const rowToSourceBinding = (
573		− row: Record<string, unknown>,
574		− ): OpenApiSourceBindingRef =>
575		− new OpenApiSourceBindingRef({
576		− sourceId: row.source_id as string,
577		− sourceScopeId: ScopeId.make(row.source_scope_id as string),
578		− scopeId: ScopeId.make(row.target_scope_id as string),
579		− slot: row.slot as string,
	627	+ const rowToSourceBinding = (row: Record<string, unknown>): OpenApiSourceBindingRef => {
	628	+ const decoded = decodeSourceBindingStorageRow(row);
	629	+ return new OpenApiSourceBindingRef({
	630	+ sourceId: decoded.source_id,
	631	+ sourceScopeId: ScopeId.make(decoded.source_scope_id),
	632	+ scopeId: ScopeId.make(decoded.target_scope_id),
	633	+ slot: decoded.slot,
580	634	value: rowToSourceBindingValue(row),
581		− createdAt:
582		− row.created_at instanceof Date
583		− ? row.created_at
584		− : new Date(row.created_at as string),
585		− updatedAt:
586		− row.updated_at instanceof Date
587		− ? row.updated_at
588		− : new Date(row.updated_at as string),
	635	+ createdAt: decodeStorageDate(decoded.created_at),
	636	+ updatedAt: decodeStorageDate(decoded.updated_at),
589	637	});
	638	+ };
	639	+
	640	+ const sourceBindingTargetScope = (row: Record<string, unknown>): string =>
	641	+ decodeSourceBindingStorageRow(row).target_scope_id;
590	642
591	643	const sourceBindingValueColumns = (
592	644	value: OpenApiSourceBindingValue,
593		− ): { kind: string; secret_id?: string; connection_id?: string; text_value?: string } => {
	645	+ ): {
	646	+ kind: string;
	647	+ secret_id?: string;
	648	+ connection_id?: string;
	649	+ text_value?: string;
	650	+ } => {
594	651	if (value.kind === "secret") {
595	652	return { kind: "secret", secret_id: value.secretId };
596	653	}
@@ -606,24 +663,20 @@ export const makeDefaultOpenapiStore = ({ · 9 unmodified lines
606	663	}) =>
607	664	Effect.gen(function* () {
608	665	if (!scopeIds.includes(params.sourceScope)) {
609		− return yield* Effect.fail(
610		− new StorageError({
611		− message:
612		− `OpenAPI source binding references source scope "${params.sourceScope}" ` +
613		− `which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
614		− cause: undefined,
615		− }),
616		− );
	666	+ return yield* new StorageError({
	667	+ message:
	668	+ `OpenAPI source binding references source scope "${params.sourceScope}" ` +
	669	+ `which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
	670	+ cause: undefined,
	671	+ });
617	672	}
618	673	if (!scopeIds.includes(params.targetScope)) {
619		− return yield* Effect.fail(
620		− new StorageError({
621		− message:
622		− `OpenAPI source binding targets scope "${params.targetScope}" which is not ` +
623		− `in the executor's scope stack [${scopeIds.join(", ")}].`,
624		− cause: undefined,
625		− }),
626		− );
	674	+ return yield* new StorageError({
	675	+ message:
	676	+ `OpenAPI source binding targets scope "${params.targetScope}" which is not ` +
	677	+ `in the executor's scope stack [${scopeIds.join(", ")}].`,
	678	+ cause: undefined,
	679	+ });
627	680	}
628	681	});
629	682
@@ -645,23 +698,19 @@ export const makeDefaultOpenapiStore = ({ · 15 unmodified lines
645	698	],
646	699	});
647	700	if (!source) {
648		− return yield* Effect.fail(
649		− new StorageError({
650		− message: `OpenAPI source "${params.sourceId}" does not exist at scope "${params.sourceScope}"`,
651		− cause: undefined,
652		− }),
653		− );
	701	+ return yield* new StorageError({
	702	+ message: `OpenAPI source "${params.sourceId}" does not exist at scope "${params.sourceScope}"`,
	703	+ cause: undefined,
	704	+ });
654	705	}
655	706	if (scopeRank(params.targetScope) > scopeRank(params.sourceScope)) {
656		− return yield* Effect.fail(
657		− new StorageError({
658		− message:
659		− `OpenAPI source bindings for "${params.sourceId}" cannot be written at ` +
660		− `outer scope "${params.targetScope}" because the base source lives at ` +
661		− `"${params.sourceScope}"`,
662		− cause: undefined,
663		− }),
664		− );
	707	+ return yield* new StorageError({
	708	+ message:
	709	+ `OpenAPI source bindings for "${params.sourceId}" cannot be written at ` +
	710	+ `outer scope "${params.targetScope}" because the base source lives at ` +
	711	+ `"${params.sourceScope}"`,
	712	+ cause: undefined,
	713	+ });
665	714	}
666	715	return source;
667	716	});
@@ -684,20 +733,15 @@ export const makeDefaultOpenapiStore = ({ · 16 unmodified lines
684	733	})
685	734	.pipe(Effect.map(childRowsToValueMap));
686	735
687		− const rowToSource = (
688		− row: Record<string, unknown>,
689		− ): Effect.Effect<StoredSource, StorageFailure> =>
	736	+ const rowToSource = (row: Record<string, unknown>): Effect.Effect<StoredSource, StorageFailure> =>
690	737	Effect.gen(function* () {
691		− const sourceId = row.id as string;
692		− const scope = row.scope_id as string;
693		− const normalizedHeaders = normalizeStoredHeaders(row.headers);
694		− const normalizedOAuth2 = normalizeStoredOAuth2(row.oauth2);
	738	+ const sourceRow = decodeSourceStorageRow(row);
	739	+ const sourceId = sourceRow.id;
	740	+ const scope = sourceRow.scope_id;
	741	+ const normalizedHeaders = normalizeStoredHeaders(sourceRow.headers);
	742	+ const normalizedOAuth2 = normalizeStoredOAuth2(sourceRow.oauth2);
695	743
696		− const queryParams = yield* loadChildValueMap(
697		− "openapi_source_query_param",
698		− sourceId,
699		− scope,
700		− );
	744	+ const queryParams = yield* loadChildValueMap("openapi_source_query_param", sourceId, scope);
701	745	const specFetchHeaders = yield* loadChildValueMap(
702	746	"openapi_source_spec_fetch_header",
703	747	sourceId,
@@ -709,13 +753,10 @@ export const makeDefaultOpenapiStore = ({ · 5 unmodified lines
709	753	scope,
710	754	);
711	755	const specFetchCredentials: OpenApiSpecFetchCredentials \| undefined =
712		− Object.keys(specFetchHeaders).length === 0 &&
713		− Object.keys(specFetchQueryParams).length === 0
	756	+ Object.keys(specFetchHeaders).length === 0 && Object.keys(specFetchQueryParams).length === 0
714	757	? undefined
715	758	: {
716		− ...(Object.keys(specFetchHeaders).length > 0
717		− ? { headers: specFetchHeaders }
718		− : {}),
	759	+ ...(Object.keys(specFetchHeaders).length > 0 ? { headers: specFetchHeaders } : {}),
719	760	...(Object.keys(specFetchQueryParams).length > 0
720	761	? { queryParams: specFetchQueryParams }
721	762	: {}),
@@ -724,38 +765,40 @@ export const makeDefaultOpenapiStore = ({ · 2 unmodified lines
724	765	return {
725	766	namespace: sourceId,
726	767	scope,
727		− name: row.name as string,
	768	+ name: sourceRow.name,
728	769	config: {
729		− spec: row.spec as string,
730		− sourceUrl: (row.source_url as string \| null \| undefined) ?? undefined,
731		− baseUrl: (row.base_url as string \| null \| undefined) ?? undefined,
	770	+ spec: sourceRow.spec,
	771	+ sourceUrl: sourceRow.source_url ?? undefined,
	772	+ baseUrl: sourceRow.base_url ?? undefined,
732	773	headers: normalizedHeaders.headers,
733	774	queryParams,
734	775	specFetchCredentials,
735	776	oauth2: normalizedOAuth2.oauth2,
736	777	},
737	778	legacy:
738		− Object.keys(normalizedHeaders.legacy).length > 0 \|\|
739		− normalizedOAuth2.legacy
	779	+ Object.keys(normalizedHeaders.legacy).length > 0 \|\| normalizedOAuth2.legacy
740	780	? {
741	781	...(Object.keys(normalizedHeaders.legacy).length > 0
742	782	? { headers: normalizedHeaders.legacy }
743	783	: {}),
744		− ...(normalizedOAuth2.legacy
745		− ? { oauth2: normalizedOAuth2.legacy }
746		− : {}),
	784	+ ...(normalizedOAuth2.legacy ? { oauth2: normalizedOAuth2.legacy } : {}),
747	785	}
748	786	: undefined,
749	787	};
750	788	});
751	789
752		− const rowToOperation = (row: Record<string, unknown>): StoredOperation => ({
753		− toolId: row.id as string,
754		− sourceId: row.source_id as string,
755		− binding: decodeBinding(
756		− typeof row.binding === "string" ? JSON.parse(row.binding) : row.binding,
757		− ),
758		− });
	790	+ const rowToOperation = (row: Record<string, unknown>): StoredOperation => {
	791	+ const operationRow = decodeOperationStorageRow(row);
	792	+ return {
	793	+ toolId: operationRow.id,
	794	+ sourceId: operationRow.source_id,
	795	+ binding: decodeBinding(
	796	+ typeof operationRow.binding === "string"
	797	+ ? decodeBindingJson(operationRow.binding)
	798	+ : operationRow.binding,
	799	+ ),
	800	+ };
	801	+ };
759	802
760	803	// Replace the rows of one child table for a source: delete then bulk
761	804	// insert. Single helper so upsertSource and updateSourceMeta both
@@ -845,20 +888,18 @@ export const makeDefaultOpenapiStore = ({ · 83 unmodified lines
845	888	source_url: input.config.sourceUrl ?? undefined,
846	889	base_url: input.config.baseUrl ?? undefined,
847	890	headers: Object.fromEntries(
848		− Object.entries(input.config.headers ?? {}).map(
849		− ([name, value]) => [
850		− name,
851		− typeof value === "string"
852		− ? value
853		− : value.kind === "binding"
854		− ? {
855		− kind: value.kind,
856		− slot: value.slot,
857		− ...(value.prefix ? { prefix: value.prefix } : {}),
858		− }
859		− : value,
860		− ],
861		− ),
	891	+ Object.entries(input.config.headers ?? {}).map(([name, value]) => [
	892	+ name,
	893	+ typeof value === "string"
	894	+ ? value
	895	+ : value.kind === "binding"
	896	+ ? {
	897	+ kind: value.kind,
	898	+ slot: value.slot,
	899	+ ...(value.prefix ? { prefix: value.prefix } : {}),
	900	+ }
	901	+ : value,
	902	+ ]),
862	903	) as Record<string, unknown>,
863	904	oauth2: input.config.oauth2
864	905	? toJsonRecord(encodeOAuth2SourceConfig(input.config.oauth2))
@@ -911,14 +952,10 @@ export const makeDefaultOpenapiStore = ({ · 46 unmodified lines
911	952	const existing = yield* rowToSource(existingRow);
912	953
913	954	const nextName = patch.name?.trim() \|\| existing.name;
914		− const nextBaseUrl =
915		− patch.baseUrl !== undefined ? patch.baseUrl : existing.config.baseUrl;
	955	+ const nextBaseUrl = patch.baseUrl !== undefined ? patch.baseUrl : existing.config.baseUrl;
916	956	const nextHeaders =
917		− patch.headers !== undefined
918		− ? patch.headers
919		− : (existing.config.headers ?? {});
920		− const nextOAuth2 =
921		− patch.oauth2 !== undefined ? patch.oauth2 : existing.config.oauth2;
	957	+ patch.headers !== undefined ? patch.headers : (existing.config.headers ?? {});
	958	+ const nextOAuth2 = patch.oauth2 !== undefined ? patch.oauth2 : existing.config.oauth2;
922	959
923	960	yield* adapter.update({
924	961	model: "openapi_source",
@@ -941,9 +978,7 @@ export const makeDefaultOpenapiStore = ({ · 16 unmodified lines
941	978	},
942	979	]),
943	980	) as Record<string, unknown>,
944		− oauth2: nextOAuth2
945		− ? toJsonRecord(encodeOAuth2SourceConfig(nextOAuth2))
946		− : undefined,
	981	+ oauth2: nextOAuth2 ? toJsonRecord(encodeOAuth2SourceConfig(nextOAuth2)) : undefined,
947	982	},
948	983	});
949	984	if (patch.queryParams !== undefined) {
@@ -999,8 +1034,7 @@ export const makeDefaultOpenapiStore = ({ · 49 unmodified lines
999	1034	})
1000	1035	.pipe(Effect.map((rows) => rows.map(rowToOperation))),
1001	1036
1002		− removeSource: (namespace, scope) =>
1003		− deleteSource(namespace, scope, { includeBindings: true }),
	1037	+ removeSource: (namespace, scope) => deleteSource(namespace, scope, { includeBindings: true }),
1004	1038
1005	1039	listSourceBindings: (sourceId, sourceScope) =>
1006	1040	Effect.gen(function* () {
@@ -1017,14 +1051,10 @@ export const makeDefaultOpenapiStore = ({ · 10 unmodified lines
1017	1051	],
1018	1052	});
1019	1053	return rows
1020		− .filter(
1021		− (row) =>
1022		− scopeRank(row.target_scope_id as string) <= sourceScopeRank,
1023		− )
	1054	+ .filter((row) => scopeRank(sourceBindingTargetScope(row)) <= sourceScopeRank)
1024	1055	.sort(
1025	1056	(a, b) =>
1026		− scopeRank(a.target_scope_id as string) -
1027		− scopeRank(b.target_scope_id as string),
	1057	+ scopeRank(sourceBindingTargetScope(a)) - scopeRank(sourceBindingTargetScope(b)),
1028	1058	)
1029	1059	.map(rowToSourceBinding);
1030	1060	}),
@@ -1045,31 +1075,24 @@ export const makeDefaultOpenapiStore = ({ · 14 unmodified lines
1045	1075	});
1046	1076	const sourceScopeRank = scopeRank(sourceScope);
1047	1077	const row = rows
1048		− .filter(
1049		− (candidate) =>
1050		− scopeRank(candidate.target_scope_id as string) <= sourceScopeRank,
1051		− )
	1078	+ .filter((candidate) => scopeRank(sourceBindingTargetScope(candidate)) <= sourceScopeRank)
1052	1079	.sort(
1053	1080	(a, b) =>
1054		− scopeRank(a.target_scope_id as string) -
1055		− scopeRank(b.target_scope_id as string),
	1081	+ scopeRank(sourceBindingTargetScope(a)) - scopeRank(sourceBindingTargetScope(b)),
1056	1082	)[0];
1057	1083	return row ? rowToSourceBinding(row) : null;
1058	1084	}),
1059	1085
1060	1086	setSourceBinding: (input) =>
1061	1087	Effect.gen(function* () {
	1088	+ const sourceScope = String(input.sourceScope);
	1089	+ const targetScope = String(input.scope);
1062	1090	yield* validateBindingTarget({
1063	1091	sourceId: input.sourceId,
1064		− sourceScope: input.sourceScope as string,
1065		− targetScope: input.scope as string,
	1092	+ sourceScope,
	1093	+ targetScope,
1066	1094	});
1067		− const id = sourceBindingRowId(
1068		− input.sourceId,
1069		− input.sourceScope as string,
1070		− input.slot,
1071		− input.scope as string,
1072		− );
	1095	+ const id = sourceBindingRowId(input.sourceId, sourceScope, input.slot, targetScope);
1073	1096	const now = new Date();
1074	1097	const valueColumns = sourceBindingValueColumns(input.value);
1075	1098	yield* adapter.delete({
@@ -1081,8 +1104,8 @@ export const makeDefaultOpenapiStore = ({ · 5 unmodified lines
1081	1104	data: {
1082	1105	id,
1083	1106	source_id: input.sourceId,
1084		− source_scope_id: input.sourceScope as string,
1085		− target_scope_id: input.scope as string,
	1107	+ source_scope_id: sourceScope,
	1108	+ target_scope_id: targetScope,
1086	1109	slot: input.slot,
1087	1110	...valueColumns,
1088	1111	created_at: now,
@@ -1139,8 +1162,14 @@ export const makeDefaultOpenapiStore = ({ · 50 unmodified lines
1139	1162	Effect.gen(function* () {
1140	1163	const tables = [
1141	1164	{ model: "openapi_source_query_param" as const, kind: "query_param" as const },
1142		− { model: "openapi_source_spec_fetch_header" as const, kind: "spec_fetch_header" as const },
1143		− { model: "openapi_source_spec_fetch_query_param" as const, kind: "spec_fetch_query_param" as const },
	1165	+ {
	1166	+ model: "openapi_source_spec_fetch_header" as const,
	1167	+ kind: "spec_fetch_header" as const,
	1168	+ },
	1169	+ {
	1170	+ model: "openapi_source_spec_fetch_query_param" as const,
	1171	+ kind: "spec_fetch_query_param" as const,
	1172	+ },
1144	1173	];
1145	1174	const perTable = yield* Effect.forEach(
1146	1175	tables,
@@ -1152,12 +1181,15 @@ export const makeDefaultOpenapiStore = ({ · 5 unmodified lines
1152	1181	})
1153	1182	.pipe(
1154	1183	Effect.map((rows) =>
1155		− rows.map((r) => ({
1156		− kind: t.kind,
1157		− source_id: r.source_id as string,
1158		− scope_id: r.scope_id as string,
1159		− name: r.name as string,
1160		− })),
	1184	+ rows.map((r) => {
	1185	+ const row = decodeChildUsageStorageRow(r);
	1186	+ return {
	1187	+ kind: t.kind,
	1188	+ source_id: row.source_id,
	1189	+ scope_id: row.scope_id,
	1190	+ name: row.name,
	1191	+ };
	1192	+ }),
1161	1193	),
1162	1194	),
1163	1195	{ concurrency: "unbounded" },
@@ -1172,8 +1204,9 @@ export const makeDefaultOpenapiStore = ({ · 8 unmodified lines
1172	1204	const requested = new Set(keys);
1173	1205	const out = new Map<string, string>();
1174	1206	for (const r of rows) {
1175		− const key = `${r.scope_id as string}:${r.id as string}`;
1176		− if (requested.has(key)) out.set(key, r.name as string);
	1207	+ const row = decodeSourceNameStorageRow(r);
	1208	+ const key = `${row.scope_id}:${row.id}`;
	1209	+ if (requested.has(key)) out.set(key, row.name);
1177	1210	}
1178	1211	return out;
1179	1212	}),

Merge remote-tracking branch 'origin/codex/batch18-openapi-boundaries' into codex/effect-lint-integration

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code