feat(oidc): refactor-wellknown-architecture

refactor well known after discussion
SDKS-4665

Author: ryanbas21

e2e/journey-app/main.ts

@@ -6,9 +6,9 @@
  */
 import './style.css';
 
-import { journey, isJourneyClient } from '@forgerock/journey-client';
+import { journey } from '@forgerock/journey-client';
 
-import type { RequestMiddleware } from '@forgerock/journey-client/types';
+import type { JourneyClient, RequestMiddleware } from '@forgerock/journey-client/types';
 
 import { renderCallbacks } from './callback-map.js';
 import { renderQRCodeStep } from './components/qr-code.js';
@@ -40,7 +40,7 @@ if (searchParams.get('middleware') === 'true') {
     },
     (req, action, next) => {
       switch (action.type) {
-        case 'END_SESSION':
+        case 'JOURNEY_TERMINATE':
           req.url.searchParams.set('end-session-middleware', 'end-session');
           req.headers.append('x-end-session-middleware', 'end-session');
           break;
@@ -55,19 +55,15 @@ if (searchParams.get('middleware') === 'true') {
   const formEl = document.getElementById('form') as HTMLFormElement;
   const journeyEl = document.getElementById('journey') as HTMLDivElement;
 
-  const journeyClientResult = await journey({ config: config, requestMiddleware });
-  if (!isJourneyClient(journeyClientResult)) {
-    console.error('Failed to initialize journey client:', journeyClientResult.message);
-    errorEl.textContent = journeyClientResult.message ?? 'Unknown error';
+  let journeyClient: JourneyClient;
+  try {
+    journeyClient = await journey({ config: config, requestMiddleware });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Failed to initialize journey client:', message);
+    errorEl.textContent = message;
     return;
   }
-  /**
-   * Re-assign to a new const after type narrowing.
-   * TypeScript's type narrowing doesn't persist into closures (event handlers, callbacks)
-   * because it can't prove the variable wasn't reassigned between the guard and closure execution.
-   * Creating a new const binding after the guard preserves the narrowed type for nested functions.
-   */
-  const journeyClient = journeyClientResult;
   let step = await journeyClient.start({ journey: journeyName });
 
   function renderComplete() {

e2e/journey-app/server-configs.ts

@@ -9,24 +9,19 @@ import type { JourneyClientConfig } from '@forgerock/journey-client/types';
 /**
  * Server configurations for E2E tests.
  *
- * Both baseUrl and realmPath are automatically inferred from the wellknown URL:
- * - baseUrl: extracted from the path before `/oauth2/`
- * - realmPath: extracted from the issuer URL in the wellknown response
+ * All configuration (baseUrl, authenticate/sessions paths) is automatically
+ * derived from the well-known response via `convertWellknown()`.
  */
 export const serverConfigs: Record<string, JourneyClientConfig> = {
   basic: {
     serverConfig: {
       wellknown: 'http://localhost:9443/am/oauth2/realms/root/.well-known/openid-configuration',
-      // baseUrl inferred: http://localhost:9443/am/
-      // realmPath inferred from issuer: 'root'
     },
   },
   tenant: {
     serverConfig: {
       wellknown:
         'https://openam-sdks.forgeblocks.com/am/oauth2/realms/root/realms/alpha/.well-known/openid-configuration',
-      // baseUrl inferred: https://openam-sdks.forgeblocks.com/am/
-      // realmPath inferred from issuer: 'alpha'
     },
   },
 };

packages/davinci-client/src/lib/client.store.ts

@@ -9,14 +9,13 @@
  */
 import { CustomLogger, logger as loggerFn, LogLevel } from '@forgerock/sdk-logger';
 import { createStorage } from '@forgerock/storage';
-import { isGenericError } from '@forgerock/sdk-utilities';
+import { isGenericError, createWellknownError } from '@forgerock/sdk-utilities';
 
 import { createClientStore, handleUpdateValidateError, RootState } from './client.store.utils.js';
 import { nodeSlice } from './node.slice.js';
 import { davinciApi } from './davinci.api.js';
 import { configSlice } from './config.slice.js';
 import { wellknownApi } from './wellknown.api.js';
-import { createWellknownError } from './wellknown.utils.js';
 
 import type { ActionTypes, RequestMiddleware } from '@forgerock/sdk-request-middleware';
 /**

packages/davinci-client/src/lib/wellknown.api.ts

@@ -7,83 +7,37 @@
 
 import { createSelector } from '@reduxjs/toolkit';
 import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query';
-import { fetchWellknownConfiguration } from '@forgerock/sdk-oidc';
+import { initWellknownQuery } from '@forgerock/sdk-oidc';
 
-import type { WellknownResponse, GenericError } from '@forgerock/sdk-types';
-import type { BaseQueryFn, FetchBaseQueryError } from '@reduxjs/toolkit/query';
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-/**
- * Converts FetchBaseQueryError to GenericError.
- */
-function toGenericError(error: FetchBaseQueryError): GenericError {
-  const status = error.status;
-  let message = `HTTP error ${String(status)}`;
-
-  if ('error' in error) {
-    message = error.error;
-  } else if ('data' in error && isObject(error.data)) {
-    if (typeof error.data['message'] === 'string') message = error.data['message'];
-    else if (typeof error.data['error'] === 'string') message = error.data['error'];
-    else if (typeof error.data['error_description'] === 'string')
-      message = error.data['error_description'];
-    else message = JSON.stringify(error.data);
-  }
-
-  return {
-    error: 'Well-known configuration fetch failed',
-    message,
-    type: 'wellknown_error',
-    status,
-  };
-}
-
-/**
- * Configured fetchBaseQuery that sets `Accept: application/json` headers.
- */
-const innerBaseQuery = fetchBaseQuery({
-  prepareHeaders: (headers) => {
-    headers.set('Accept', 'application/json');
-    return headers;
-  },
-});
-
-/**
- * BaseQuery wrapper that normalizes FetchBaseQueryError to GenericError.
- *
- * This allows the wellknownApi to use GenericError as its error type
- * while the actual HTTP transport goes through RTK Query's pipeline.
- */
-const wellknownBaseQuery: BaseQueryFn<string, unknown, GenericError> = async (
-  args,
-  api,
-  extraOptions,
-) => {
-  const result = await innerBaseQuery(args, api, extraOptions);
-  if (result.error) {
-    return { ...result, error: toGenericError(result.error) };
-  }
-  return result;
-};
+import type { WellknownResponse } from '@forgerock/sdk-types';
+import type {
+  FetchBaseQueryError,
+  FetchBaseQueryMeta,
+  QueryReturnValue,
+} from '@reduxjs/toolkit/query';
 
 /**
  * RTK Query API for well-known endpoint discovery.
  *
- * Uses `queryFn` to pass the baseQuery into the framework-agnostic
- * `fetchWellknownConfiguration` effect, which handles response validation.
- * The baseQuery handles HTTP transport.
+ * Uses the `initWellknownQuery` builder pattern from `@forgerock/sdk-oidc`.
+ * The builder constructs the request and validates the response;
+ * `fetchBaseQuery` handles the HTTP transport through RTK Query's pipeline.
  */
 export const wellknownApi = createApi({
   reducerPath: 'wellknown',
-  baseQuery: wellknownBaseQuery,
+  baseQuery: fetchBaseQuery(),
   endpoints: (builder) => ({
     configuration: builder.query<WellknownResponse, string>({
       queryFn: async (url, _api, _extra, baseQuery) => {
-        const result = await fetchWellknownConfiguration(url, baseQuery);
-        return result.success ? { data: result.data } : { error: result.error };
+        const result = await initWellknownQuery(url).applyQuery(async (req) => {
+          const queryResult = await baseQuery(req);
+          return queryResult as QueryReturnValue<unknown, FetchBaseQueryError, FetchBaseQueryMeta>;
+        });
+        return result as QueryReturnValue<
+          WellknownResponse,
+          FetchBaseQueryError,
+          FetchBaseQueryMeta
+        >;
       },
     }),
   }),