@epam/ai-dial-chat-hooks 1.3.0-dev.32 → 1.3.0-dev.321

package/oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.js

@@ -1,94 +1,93 @@
 import { TOOLSET_REDIRECT_STATE_KEY as e, ToolsetCredentialsLevel as t, ToolsetOAuthCallbackQuery as n, ToolsetOAuthChannelControlType as r, ToolsetOAuthFailureReason as i, ToolsetOAuthResultType as a } from "../types.js";
 import { getToolsetOAuthChannelName as o } from "../handshake.js";
-import { useEffect as s, useRef as c, useState as l } from "react";
+import { decodeJsonFromBase64 as s } from "@epam/ai-dial-chat-shared";
+import { useEffect as c, useRef as l, useState as u } from "react";
 //#region src/oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.ts
-var u = 500, d = (e) => typeof e == "object" && !!e && "type" in e && e.type === r.ResultAcknowledged, f = () => {
+var d = 500, f = (e) => typeof e == "object" && !!e && "type" in e && e.type === r.ResultAcknowledged, p = () => {
 	let t = sessionStorage.getItem(e);
 	if (!t) return null;
 	try {
-		return JSON.parse(t);
+		return s(t);
 	} catch {
-		return null;
+		try {
+			return JSON.parse(t);
+		} catch {
+			return null;
+		}
 	}
-}, p = (e) => {
+}, m = (e) => {
 	try {
 		window.history.replaceState({}, document.title, `${e.pathname}${e.search}`);
 	} catch {}
-}, m = (e, t) => {
+}, h = (e, t) => {
 	let r = new URL(window.location.pathname, window.location.origin);
-	if (r.searchParams.set(n.Result, t.type), t.type === a.Failure && r.searchParams.set(n.FailureReason, t.reason), p(r), !e) {
-		window.close();
-		return;
-	}
-	try {
+	if (r.searchParams.set(n.Result, t.type), t.type === a.Failure && r.searchParams.set(n.FailureReason, t.reason), m(r), !e) window.close();
+	else try {
 		let n = new BroadcastChannel(o(e));
 		n.postMessage(t);
 		let r = setInterval(() => {
 			n.postMessage(t);
-		}, u);
+		}, d);
 		n.onmessage = (e) => {
-			d(e.data) && (clearInterval(r), n.close(), window.close());
+			f(e.data) && (clearInterval(r), n.close(), window.close());
 		};
 	} catch {}
-}, h = ({ searchParams: n, callbackPath: r, exchange: o }) => {
-	let [u, d] = l(!0), [h, g] = l(null), _ = c(!1), v = c(o);
+}, g = ({ searchParams: n, callbackPath: r, exchange: o }) => {
+	let [s, d] = u(!0), [f, g] = u(null), _ = l(!1), v = l(o);
 	v.current = o;
-	let y = c(r);
-	return y.current = r, s(() => {
-		if (_.current) return;
-		_.current = !0;
-		let r = (e, t) => {
-			m(e, t), d(!1), g(t.type === a.Failure ? t.reason : null);
-		};
-		(async () => {
-			let o = n.get("code"), s = n.get("state"), c = f();
+	let y = l(r);
+	return y.current = r, c(() => {
+		_.current || (_.current = !0, (async () => {
+			let r = n.get("code"), o = n.get("state"), s = p();
 			sessionStorage.removeItem(e);
-			let l = c?.state ?? s ?? void 0;
-			if (p(new URL(window.location.pathname, window.location.origin)), !o || !c?.toolsetId) {
-				r(l, {
+			let c = s?.state ?? o ?? void 0, l = (e, t) => {
+				h(e, t), d(!1), g(t.type === a.Failure ? t.reason : null);
+			};
+			if (m(new URL(window.location.pathname, window.location.origin)), !r || !s?.toolsetId) {
+				l(c, {
 					type: a.Failure,
-					reason: c?.toolsetId ? i.MissingCode : i.MissingRedirectState
+					reason: s?.toolsetId ? i.MissingCode : i.MissingRedirectState
 				});
 				return;
 			}
-			if (c.state != null && c.state !== s) {
-				r(l, {
+			if (s.state != null && s.state !== o) {
+				l(c, {
 					type: a.Failure,
 					reason: i.StateMismatch
 				});
 				return;
 			}
-			let u = c.credentialsLevel ?? t.User, d = c.redirectUri ?? `${window.location.origin}${y.current}`;
+			let u = s.credentialsLevel ?? t.User, f = s.redirectUri ?? `${window.location.origin}${y.current}`;
 			try {
 				let e = await v.current({
-					code: o,
-					redirectUri: d,
+					code: r,
+					redirectUri: f,
 					credentialsLevel: u,
-					redirectState: c
+					redirectState: s
 				});
 				if (e != null) {
-					r(l, {
+					l(c, {
 						type: a.Failure,
 						reason: e
 					});
 					return;
 				}
-				r(l, {
+				l(c, {
 					type: a.Success,
-					toolsetId: c.toolsetId,
+					toolsetId: s.toolsetId,
 					credentialsLevel: u
 				});
 			} catch {
-				r(l, {
+				l(c, {
 					type: a.Failure,
 					reason: i.LoginRequestFailed
 				});
 			}
-		})();
+		})());
 	}, [n]), {
-		isInProgress: u,
-		failureReason: h
+		isInProgress: s,
+		failureReason: f
 	};
 };
 //#endregion
-export { h as useOAuthCallbackCompletion };
+export { g as useOAuthCallbackCompletion };

package/oauth/useToolsetLogin/useToolsetLogin.d.ts

@@ -0,0 +1,85 @@
+import { DialToolsetDto, ToolsetLoginBodyDto, ToolsetLogoutBodyDto } from '@epam/ai-dial-chat-api-client';
+import { ToolsetOAuthSettings } from '../models';
+import { ToolsetAuthTypes, ToolsetCredentialsLevel } from '../types';
+/** Terminal outcome kinds `login` can resolve. */
+export declare enum ToolsetLoginOutcomeType {
+    Success = "success",
+    Failure = "failure",
+    PopupBlocked = "popup-blocked",
+    Cancelled = "cancelled"
+}
+/** Discriminated outcome of one login attempt. */
+export interface ToolsetLoginOutcome {
+    /** Which terminal branch the attempt resolved through. */
+    type: ToolsetLoginOutcomeType;
+}
+/** Arguments for one `login` call. */
+export interface ToolsetLoginParams {
+    /** Already-encoded toolset id/url, as returned by `listToolsets`/`getToolset`. */
+    toolsetId: string;
+    /** Credentials level the submitted credentials apply to. */
+    credentialsLevel: ToolsetCredentialsLevel;
+    /** Authentication mechanism the toolset requires. */
+    authenticationType: ToolsetAuthTypes;
+    /** Required for `ToolsetAuthTypes.ApiKey`. */
+    apiKey?: string;
+    /** Required for `ToolsetAuthTypes.OAuth`. */
+    oauthSettings?: ToolsetOAuthSettings;
+    /**
+     * Whether the target level's cached status is currently `FAILED` — API key
+     * logins log that level out first when true. Ignored when `forceStale` is
+     * set, and never consulted for OAuth (OAuth does not log out before
+     * retrying).
+     */
+    isCurrentlyFailed?: boolean;
+    /**
+     * Always logs out the target level first (for both API key and OAuth)
+     * regardless of the cached status — set by callers reacting to a
+     * DIAL-Core-pushed `toolset/signin` event, which is proof the cached
+     * status may be stale even when it still reads `SIGNED_IN`.
+     */
+    forceStale?: boolean;
+    /**
+     * Whether the user agreed an application may use this credential while they
+     * are away. DIAL Core gates every on-behalf-of mint on it, so a toolset
+     * signed in without it works interactively and still fails with
+     * `consent-required` in the background. Absent means not granted.
+     */
+    offlineUsageConsent?: boolean;
+}
+/** Parameters for {@link useToolsetLogin}. */
+export interface UseToolsetLoginParams {
+    /**
+     * The host's OAuth callback route. Resolved against `window.location.origin`
+     * for the `redirect_uri`, and compared against the popup's pathname when
+     * reading a completion marker out of its URL.
+     */
+    callbackPath: string;
+    /** Submits credentials for one toolset at one credentials level. */
+    loginToolset: (toolsetId: string, body: ToolsetLoginBodyDto) => Promise<unknown>;
+    /** Clears stored credentials for one toolset at one credentials level. */
+    logoutToolset: (toolsetId: string, body: ToolsetLogoutBodyDto) => Promise<unknown>;
+    /** Re-reads a toolset so a reported cancellation can be checked against the backend. */
+    getToolset: (toolsetId: string) => Promise<DialToolsetDto>;
+    /**
+     * Whether an OAuth login reads the toolset's current OAuth settings with
+     * `getToolset` after opening the popup, instead of using
+     * `ToolsetLoginParams.oauthSettings`. Defaults to `false`.
+     */
+    shouldFetchOAuthSettings?: boolean;
+}
+/** Result returned by {@link useToolsetLogin}. */
+export interface UseToolsetLoginResult {
+    /** Runs one API-key or OAuth login attempt and resolves its outcome. */
+    login: (params: ToolsetLoginParams) => Promise<ToolsetLoginOutcome>;
+}
+/**
+ * Shared toolset API-key/OAuth login orchestration, so no two surfaces fork
+ * the popup/`BroadcastChannel` handshake or the stale-credential-clearing
+ * rule. Every backend call arrives as an injected callback: the hook
+ * constructs no client instance and reads no app context. It resolves an
+ * outcome and shows nothing itself — mapping an outcome to notifications is
+ * the caller's job.
+ */
+export declare const useToolsetLogin: ({ callbackPath, loginToolset, logoutToolset, getToolset, shouldFetchOAuthSettings, }: UseToolsetLoginParams) => UseToolsetLoginResult;
+//# sourceMappingURL=useToolsetLogin.d.ts.map

package/oauth/useToolsetLogin/useToolsetLogin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToolsetLogin.d.ts","sourceRoot":"","sources":["../../../src/oauth/useToolsetLogin/useToolsetLogin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAOtD,OAAO,EAGL,gBAAgB,EAChB,uBAAuB,EAGxB,MAAM,UAAU,CAAC;AAElB,kDAAkD;AAClD,oBAAY,uBAAuB;IACjC,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,YAAY,kBAAkB;IAC9B,SAAS,cAAc;CACxB;AAED,kDAAkD;AAClD,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,IAAI,EAAE,uBAAuB,CAAC;CAC/B;AAED,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C,qDAAqD;IACrD,kBAAkB,EAAE,gBAAgB,CAAC;IACrC,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,YAAY,EAAE,CACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,KACtB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,0EAA0E;IAC1E,aAAa,EAAE,CACb,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,oBAAoB,KACvB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,wFAAwF;IACxF,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3D;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,KAAK,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,sFAM7B,qBAAqB,KAAG,qBA+L1B,CAAC"}

package/oauth/useToolsetLogin/useToolsetLogin.js

@@ -1,73 +1,82 @@
 import { OAuthResourceKind as e, ToolsetAuthStatus as t, ToolsetAuthTypes as n, ToolsetOAuthInitiationResultType as r, ToolsetOAuthResultType as i } from "../types.js";
 import { selectToolsetAuthStatus as a } from "../toolset-id.js";
-import { emitToolsetLoginSuccess as o } from "../../shared/toolset-login-events.js";
-import { waitForToolsetOAuthResult as s } from "../handshake.js";
-import { initiateOAuthLogin as c, navigateToolsetOAuthPopup as l, openToolsetOAuthPopup as u } from "../popup.js";
-import { useCallback as d } from "react";
+import { toToolsetOAuthSettings as o } from "../authorize-url.js";
+import { emitToolsetLoginSuccess as s } from "../../shared/toolset-login-events.js";
+import { waitForToolsetOAuthResult as c } from "../handshake.js";
+import { initiateOAuthLogin as l, navigateToolsetOAuthPopup as u, openToolsetOAuthPopup as d } from "../popup.js";
+import { useCallback as f } from "react";
 //#region src/oauth/useToolsetLogin/useToolsetLogin.ts
-var f = /* @__PURE__ */ function(e) {
+var p = /* @__PURE__ */ function(e) {
 	return e.Success = "success", e.Failure = "failure", e.PopupBlocked = "popup-blocked", e.Cancelled = "cancelled", e;
-}({}), p = ({ callbackPath: f, loginToolset: p, logoutToolset: m, getToolset: h }) => {
-	let g = d(async (e, t, n) => {
+}({}), m = ({ callbackPath: p, loginToolset: m, logoutToolset: h, getToolset: g, shouldFetchOAuthSettings: _ = !1 }) => {
+	let v = f(async (e, t, n) => {
 		try {
-			await m(e, {
+			await h(e, {
 				url: e,
 				credentialsLevel: t,
 				authenticationType: n
 			});
 		} catch {}
-	}, [m]), _ = d(async (d) => {
-		let { toolsetId: p, credentialsLevel: m, oauthSettings: _, forceStale: v, offlineUsageConsent: y } = d, b = {
-			clientId: _?.clientId,
-			authorizationEndpoint: _?.authorizationEndpoint,
-			scopes: _?.scopes,
-			codeChallenge: _?.codeChallenge,
-			codeChallengeMethod: _?.codeChallengeMethod
-		}, x = v ? await (async () => {
-			let t = u();
-			return t ? (await g(p, m, n.OAuth), l(t, b, p, f, m, e.Toolset, y)) : { type: r.Blocked };
-		})() : c(b, p, f, m, y);
-		if (x.type === r.Blocked) return { type: "popup-blocked" };
-		if (x.type !== r.Started) return { type: "failure" };
-		let S = await s(x.popup, x.flowId, {
-			toolsetId: p,
-			credentialsLevel: m,
-			callbackPath: f
+	}, [h]), y = f(async (f) => {
+		let { toolsetId: m, credentialsLevel: h, oauthSettings: y, forceStale: b, offlineUsageConsent: x } = f, S = y ?? {}, C;
+		if (b || _) {
+			let t = d();
+			if (!t) return { type: "popup-blocked" };
+			b && await v(m, h, n.OAuth);
+			let r = S;
+			if (_) try {
+				let { authSettings: e } = await g(m);
+				if (t.closed) return { type: "cancelled" };
+				if (e?.authenticationType !== n.OAuth) return t.close(), { type: "failure" };
+				r = o(e);
+			} catch {
+				return t.close(), { type: "failure" };
+			}
+			C = u(t, r, m, p, h, e.Toolset, x);
+		} else C = l(S, m, p, h, x);
+		if (C.type === r.Blocked) return { type: "popup-blocked" };
+		if (C.type !== r.Started) return { type: "failure" };
+		let w = await c(C.popup, C.flowId, {
+			toolsetId: m,
+			credentialsLevel: h,
+			callbackPath: p
 		});
-		if (S.type === i.Success) return o({
-			toolsetId: p,
-			credentialsLevel: m
+		if (w.type === i.Success) return s({
+			toolsetId: m,
+			credentialsLevel: h
 		}), { type: "success" };
-		if (S.type === i.Failure) return { type: "failure" };
+		if (w.type === i.Failure) return { type: "failure" };
 		try {
-			if (a((await h(p)).authSettings, m) === t.SignedIn) return o({
-				toolsetId: p,
-				credentialsLevel: m
+			let e = await g(m);
+			if (a(e.authSettings, h) === t.SignedIn) return s({
+				toolsetId: m,
+				credentialsLevel: h
 			}), { type: "success" };
 		} catch {}
 		return { type: "cancelled" };
 	}, [
-		f,
-		h,
-		g
-	]), v = d(async (e) => {
-		let { toolsetId: t, credentialsLevel: n, authenticationType: r, apiKey: i, isCurrentlyFailed: a, forceStale: s, offlineUsageConsent: c } = e;
+		p,
+		g,
+		v,
+		_
+	]), b = f(async (e) => {
+		let { toolsetId: t, credentialsLevel: n, authenticationType: r, apiKey: i, isCurrentlyFailed: a, forceStale: o, offlineUsageConsent: c } = e;
 		try {
-			return (s || a) && await g(t, n, r), await p(t, {
+			return (o || a) && await v(t, n, r), await m(t, {
 				url: t,
 				credentialsLevel: n,
 				authenticationType: r,
 				apiKey: i?.trim(),
 				offlineUsageConsent: c
-			}), o({
+			}), s({
 				toolsetId: t,
 				credentialsLevel: n
 			}), { type: "success" };
 		} catch {
 			return { type: "failure" };
 		}
-	}, [p, g]);
-	return { login: d((e) => e.authenticationType === n.OAuth ? _(e) : v(e), [_, v]) };
+	}, [m, v]);
+	return { login: f((e) => e.authenticationType === n.OAuth ? y(e) : b(e), [y, b]) };
 };
 //#endregion
-export { f as ToolsetLoginOutcomeType, p as useToolsetLogin };
+export { p as ToolsetLoginOutcomeType, m as useToolsetLogin };