@salesforce/ui-bundle-template-app-react-template-b2e 11.55.1 → 11.56.0

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/contentTypeSessionCache.ts

@@ -0,0 +1,134 @@
+/**
+ * `sessionStorage`-backed persistence for discovered CMS content types.
+ *
+ * Discovery is otherwise ephemeral: the in-memory module cache in
+ * {@link useSearchableContentTypes} is wiped on a hard reload, and content
+ * types are only re-derived once a CMS search actually returns a channel id.
+ * Persisting them per channel lets the scope dropdown keep showing the
+ * discovered types across any number of reloads, and lets the discovery hook
+ * rehydrate them synchronously (no re-fetch) on mount.
+ *
+ * Two things are persisted:
+ *   - `types:<channelId>`           — the validated `{ fqn, label }[]` for that
+ *     channel. Keyed by the channel id, which is channel-specific already.
+ *   - `last-channel-id:<uiBundleId>` — the most recently discovered channel id
+ *     FOR THAT UIBundle, so the hook can seed its discovery state on mount
+ *     before any CMS result arrives. Keyed by UIBundle id (not origin-wide):
+ *     content types are channel-specific, so a second UIBundle opened in the
+ *     same session must NOT inherit the first bundle's channel/types.
+ *
+ * Every access is wrapped: `sessionStorage` can be absent (SSR), throw
+ * (private-mode / disabled cookies), or hold corrupt JSON. On any failure we
+ * degrade to "no cache" rather than surfacing an error — persistence is an
+ * enhancement, never a hard dependency.
+ */
+
+import { isValidCmsFqn, type DiscoveredContentType } from "./contentTypeUtils";
+import { CHANNEL_ID_PATTERN } from "./api/searchableContentTypesService";
+import { UI_BUNDLE_ID_PATTERN } from "./searchChannel";
+
+const KEY_PREFIX = "cms-search:content-types:";
+const TYPES_KEY = (channelId: string) => `${KEY_PREFIX}types:${channelId}`;
+const LAST_CHANNEL_KEY = (uiBundleId: string) => `${KEY_PREFIX}last-channel-id:${uiBundleId}`;
+
+/** Returns the `sessionStorage` object, or `null` when it is unavailable/throws. */
+function storage(): Storage | null {
+	try {
+		if (typeof sessionStorage === "undefined") return null;
+		return sessionStorage;
+	} catch {
+		// Accessing `sessionStorage` can throw when storage is disabled.
+		return null;
+	}
+}
+
+/** Narrows an unknown parsed value to a clean `DiscoveredContentType[]`. */
+function sanitize(parsed: unknown): DiscoveredContentType[] {
+	if (!Array.isArray(parsed)) return [];
+	const out: DiscoveredContentType[] = [];
+	const seen = new Set<string>();
+	for (const entry of parsed) {
+		if (!entry || typeof entry !== "object") continue;
+		const { fqn, label } = entry as { fqn?: unknown; label?: unknown };
+		// Re-validate the FQN on read: cached data is untrusted input and its
+		// values flow straight into the query variable and rendered labels.
+		if (typeof fqn !== "string" || !isValidCmsFqn(fqn) || seen.has(fqn)) continue;
+		if (typeof label !== "string" || label.length === 0) continue;
+		seen.add(fqn);
+		out.push({ fqn, label });
+	}
+	return out;
+}
+
+/**
+ * Reads the persisted content types for `channelId`. Returns `null` when there
+ * is no (valid) cache entry, so callers can distinguish "never persisted" from
+ * "persisted as empty".
+ */
+export function readCachedContentTypes(channelId: string): DiscoveredContentType[] | null {
+	const store = storage();
+	if (!store || !CHANNEL_ID_PATTERN.test(channelId)) return null;
+	let raw: string | null;
+	try {
+		raw = store.getItem(TYPES_KEY(channelId));
+	} catch {
+		return null;
+	}
+	if (raw == null) return null;
+	try {
+		return sanitize(JSON.parse(raw));
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Persists `types` for `channelId`. No-ops (never throws) when storage is
+ * unavailable or the id is malformed. The last-discovered-channel pointer is
+ * written separately via {@link writeLastChannelId}, which needs the UIBundle
+ * id this channel belongs to.
+ */
+export function writeCachedContentTypes(channelId: string, types: DiscoveredContentType[]): void {
+	const store = storage();
+	if (!store || !CHANNEL_ID_PATTERN.test(channelId)) return;
+	try {
+		store.setItem(TYPES_KEY(channelId), JSON.stringify(types));
+	} catch {
+		// Quota exceeded / disabled storage — persistence is best-effort.
+	}
+}
+
+/**
+ * Records `channelId` as the last discovered channel FOR `uiBundleId`. Keyed by
+ * UIBundle id so a different bundle opened in the same session never inherits
+ * this channel. No-ops (never throws) when storage is unavailable or either id
+ * is malformed.
+ */
+export function writeLastChannelId(uiBundleId: string, channelId: string): void {
+	const store = storage();
+	if (!store || !UI_BUNDLE_ID_PATTERN.test(uiBundleId) || !CHANNEL_ID_PATTERN.test(channelId)) {
+		return;
+	}
+	try {
+		store.setItem(LAST_CHANNEL_KEY(uiBundleId), channelId);
+	} catch {
+		// Quota exceeded / disabled storage — persistence is best-effort.
+	}
+}
+
+/**
+ * Returns the last discovered channel id for `uiBundleId` (validated shape), or
+ * `null`. Lets the discovery hook seed its channel on mount so THIS bundle's
+ * cached types render immediately, before any CMS search result comes back.
+ */
+export function readLastChannelId(uiBundleId: string): string | null {
+	const store = storage();
+	if (!store || !UI_BUNDLE_ID_PATTERN.test(uiBundleId)) return null;
+	let raw: string | null;
+	try {
+		raw = store.getItem(LAST_CHANNEL_KEY(uiBundleId));
+	} catch {
+		return null;
+	}
+	return raw != null && CHANNEL_ID_PATTERN.test(raw) ? raw : null;
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/contentTypeUtils.ts

@@ -0,0 +1,38 @@
+/**
+ * CMS content-type FQN helpers.
+ *
+ * `isValidCmsFqn` / `CMS_FQN_PATTERN` guard every FQN before it enters query
+ * state, the GraphQL variable, or a rendered label. `formatContentTypeLabel`
+ * turns an FQN into a human-readable dropdown/section label.
+ */
+
+/**
+ * Formats a CMS content type FQN into a human-readable label.
+ * Strips "sfdc_cms__" prefix, splits camelCase, title-cases each word.
+ *
+ * Examples:
+ *   "sfdc_cms__blogPost" → "Blog Post"
+ *   "sfdc_cms__news" → "News"
+ *   "sfdc_cms__document" → "Document"
+ *   "sfdc_cms__pressRelease" → "Press Release"
+ */
+export function formatContentTypeLabel(fqn: string): string {
+	const stripped = fqn.replace(/^sfdc_cms__/, "");
+	const words = stripped.replace(/([a-z])([A-Z])/g, "$1 $2");
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+export const CMS_FQN_PATTERN = /^sfdc_cms__[a-zA-Z][a-zA-Z0-9]{0,39}$/;
+
+export function isValidCmsFqn(fqn: string): boolean {
+	return CMS_FQN_PATTERN.test(fqn);
+}
+
+/**
+ * A discovered CMS content type: its FQN (`sfdc_cms__…`, used as the scope value
+ * and query filter) and its server-provided display `label` (e.g. "News").
+ */
+export interface DiscoveredContentType {
+	fqn: string;
+	label: string;
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/hooks/useSearchableContentTypes.ts

@@ -0,0 +1,128 @@
+/**
+ * Session-cache hook for a CMS channel's searchable content types.
+ *
+ * A module-level `Map` cache + a `Map` of in-flight promises, keyed by
+ * `channelId`, so the Connect endpoint is hit once per channel per session and
+ * concurrent callers share one request. A `null` channelId short-circuits (no
+ * fetch) — discovery only runs after a CMS result yields a channel id.
+ */
+
+import { useState, useEffect, useRef } from "react";
+import { fetchSearchableContentTypes } from "../api/searchableContentTypesService";
+import type { DiscoveredContentType } from "../contentTypeUtils";
+import { readCachedContentTypes, writeCachedContentTypes } from "../contentTypeSessionCache";
+
+/** Session cache: channelId → discovered content types. Populated once, reused after. */
+const cache = new Map<string, DiscoveredContentType[]>();
+/** In-flight dedupe: channelId → the pending fetch promise. */
+const inflight = new Map<string, Promise<DiscoveredContentType[]>>();
+
+/**
+ * Returns any already-known content types for `channelId` WITHOUT fetching:
+ * the in-memory module cache first, then the `sessionStorage` cache (which
+ * survives a hard reload). The `sessionStorage` hit is promoted into the module
+ * cache so subsequent lookups stay in memory. Returns `null` when neither holds
+ * the channel, so callers know a network fetch is still required.
+ */
+function peekCachedContentTypes(channelId: string): DiscoveredContentType[] | null {
+	const inMemory = cache.get(channelId);
+	if (inMemory) return inMemory;
+	const persisted = readCachedContentTypes(channelId);
+	if (persisted) {
+		cache.set(channelId, persisted);
+		return persisted;
+	}
+	return null;
+}
+
+/**
+ * Fetches (once per session) and caches the searchable content types for a
+ * channel. Concurrent callers for the same channel share one request. Results
+ * are cached in memory AND persisted to `sessionStorage` so a hard reload can
+ * rehydrate them without a re-fetch.
+ */
+export function getSearchableContentTypes(channelId: string): Promise<DiscoveredContentType[]> {
+	const cached = peekCachedContentTypes(channelId);
+	if (cached) return Promise.resolve(cached);
+
+	const pending = inflight.get(channelId);
+	if (pending) return pending;
+
+	const promise = (async () => {
+		try {
+			const result = await fetchSearchableContentTypes(channelId);
+			cache.set(channelId, result);
+			// Persist so the scope dropdown keeps the types across hard reloads.
+			writeCachedContentTypes(channelId, result);
+			return result;
+		} finally {
+			inflight.delete(channelId);
+		}
+	})();
+	inflight.set(channelId, promise);
+	return promise;
+}
+
+export interface UseSearchableContentTypesResult {
+	/** Discovered, validated content types (FQN + label; empty until resolved). */
+	contentTypes: DiscoveredContentType[];
+	loading: boolean;
+	error: string | null;
+}
+
+/**
+ * React hook wrapping {@link getSearchableContentTypes}. Re-runs only when the
+ * `channelId` string changes; a `null` id yields an empty, non-loading state.
+ */
+export function useSearchableContentTypes(
+	channelId: string | null,
+): UseSearchableContentTypesResult {
+	// Seed synchronously from the in-memory OR sessionStorage cache so a hard
+	// reload shows the persisted content types on the first render (before any
+	// CMS search result comes back), with no fetch and no loading flash.
+	const [state, setState] = useState<UseSearchableContentTypesResult>(() => {
+		const seeded = channelId ? peekCachedContentTypes(channelId) : null;
+		return {
+			contentTypes: seeded ?? [],
+			loading: channelId != null && seeded == null,
+			error: null,
+		};
+	});
+	const isCancelled = useRef(false);
+
+	useEffect(() => {
+		isCancelled.current = false;
+
+		if (channelId == null) {
+			setState({ contentTypes: [], loading: false, error: null });
+			return;
+		}
+
+		const cached = peekCachedContentTypes(channelId);
+		if (cached) {
+			setState({ contentTypes: cached, loading: false, error: null });
+			return;
+		}
+
+		setState((s) => ({ ...s, loading: true, error: null }));
+		getSearchableContentTypes(channelId)
+			.then((contentTypes) => {
+				if (isCancelled.current) return;
+				setState({ contentTypes, loading: false, error: null });
+			})
+			.catch((err) => {
+				if (isCancelled.current) return;
+				setState({
+					contentTypes: [],
+					loading: false,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			});
+
+		return () => {
+			isCancelled.current = true;
+		};
+	}, [channelId]);
+
+	return state;
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/index.ts

@@ -0,0 +1,54 @@
+/**
+ * CMS adapter — fronts the `managed_content` GraphQL block behind the
+ * kind-agnostic {@link SourceAdapter} contract.
+ *
+ * `buildRequest` is SYNCHRONOUS (the query builder is sync): it reads the
+ * already-resolved `request.uiBundleId` (the caller resolves the async
+ * `getUIBundleId()` upstream and threads it in), decodes `afterCursor` → offset,
+ * and passes `request.contentTypes` through to the fragment builder ONLY when
+ * non-empty (bootstrap omits them). `parseResponse` delegates to the CMS parser.
+ *
+ * The registry (`../registry.ts`) imports `cmsAdapter` from here by name.
+ */
+
+import type { CmsSourceConfig } from "./types";
+import type { SourceAdapter, SourceRequest, QueryFragmentContribution } from "../types";
+import { buildCmsQueryFragment } from "./cmsQueryFragment";
+import { parseCmsResponse } from "./parseResponse";
+import { isValidCmsFqn } from "./contentTypeUtils";
+
+/** Decodes an opaque forward cursor into a non-negative integer offset. */
+function decodeOffset(afterCursor: string | undefined): number {
+	if (afterCursor == null) return 0;
+	const parsed = parseInt(afterCursor, 10);
+	if (!Number.isFinite(parsed) || parsed < 0) return 0;
+	return parsed;
+}
+
+/**
+ * Builds the CMS fragment contribution from a request. Content types are passed
+ * through only when non-empty AND every entry is a valid FQN (defence in depth —
+ * `useSearch` already validates before state).
+ */
+function buildCmsRequest(request: SourceRequest<CmsSourceConfig>): QueryFragmentContribution {
+	const offset = decodeOffset(request.afterCursor);
+
+	const contentTypes =
+		Array.isArray(request.contentTypes) && request.contentTypes.length > 0
+			? request.contentTypes.filter(isValidCmsFqn)
+			: null;
+
+	return buildCmsQueryFragment({
+		keyword: request.q,
+		uiBundleId: request.uiBundleId ?? "",
+		offset,
+		limit: request.pageSize,
+		contentTypes: contentTypes && contentTypes.length > 0 ? contentTypes : null,
+	});
+}
+
+export const cmsAdapter: SourceAdapter<CmsSourceConfig> = {
+	kind: "cms",
+	buildRequest: buildCmsRequest,
+	parseResponse: parseCmsResponse,
+};

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/parseResponse.ts

@@ -0,0 +1,65 @@
+/**
+ * CMS response parser: `root.managed_content.search.searchContentInChannels` →
+ * {@link SourceResult}, normalising CMS offset paging onto the common
+ * cursor-shaped {@link SourcePageInfo}.
+ *
+ * Partial-failure leniency: every level is guarded and the function returns
+ * `null` — never throws — when its subtree is absent or errored.
+ *
+ * Offset → pageInfo:
+ *   - `totalCount     = total`
+ *   - `hasNextPage    = offset + items.length < total`
+ *   - `hasPreviousPage= offset > 0`
+ *   - `endCursor      = String(offset + pageSize)`  (the caller's request page size)
+ *   - `startCursor    = String(offset)`
+ */
+
+import type { CmsSourceConfig, CmsSearchResponse } from "./types";
+import type { SourceResult } from "../../types";
+import type { SourceRequest } from "../types";
+
+/** Narrows an unknown value to a plain object (or `undefined`). */
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value != null && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+/**
+ * Reads the CMS subtree from the full response `data` root and maps it to a
+ * {@link SourceResult}. Returns `null` when the subtree is absent/errored.
+ *
+ * `pageSize` for the cursor math is taken from the request (the page size we
+ * asked for), matching `buildRequest`'s `$cmsLimit = request.pageSize`, so
+ * next/prev advances the offset by exactly one page.
+ */
+export function parseCmsResponse(
+	root: Record<string, unknown>,
+	request: SourceRequest<CmsSourceConfig>,
+): SourceResult | null {
+	const managedContent = asRecord(root?.managed_content);
+	const search = asRecord(managedContent?.search);
+	const raw = asRecord(search?.searchContentInChannels);
+	if (!raw) return null;
+
+	const response = raw as unknown as CmsSearchResponse;
+
+	const items = Array.isArray(response.items) ? response.items : [];
+	const total = typeof response.total === "number" ? response.total : null;
+	const offset = typeof response.offset === "number" ? response.offset : 0;
+	const pageSize = request.pageSize;
+
+	const hasNextPage = total != null ? offset + items.length < total : false;
+	const hasPreviousPage = offset > 0;
+
+	return {
+		nodes: items,
+		pageInfo: {
+			hasNextPage,
+			hasPreviousPage,
+			startCursor: String(offset),
+			endCursor: String(offset + pageSize),
+		},
+		totalCount: total,
+	};
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/searchChannel.ts

@@ -0,0 +1,15 @@
+import { getCurrentApp } from "@salesforce/platform-sdk";
+
+/** Returns the UIBundle id for CMS search, resolved from the running app. */
+export async function getUIBundleId(): Promise<string> {
+	const app = await getCurrentApp();
+	return app.identity?.bundleId ?? "";
+}
+
+/** Shape guard for a UIBundle record id (9YE + 12-15 alphanumerics). */
+export const UI_BUNDLE_ID_PATTERN = /^9YE[a-zA-Z0-9]{12,15}$/;
+
+/** True when `id` is a well-formed (9YE-shaped) UIBundle id. */
+export function isConfiguredUIBundleId(id: string): boolean {
+	return UI_BUNDLE_ID_PATTERN.test(id.trim());
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/cms/types.ts

@@ -0,0 +1,66 @@
+/**
+ * CMS source config + the response shapes returned by
+ * `managed_content.search.searchContentInChannels`.
+ */
+
+export interface CmsChannelDetails {
+	id: string;
+	name: string;
+	type?: string;
+}
+
+export interface CmsChannelDeliveryDetails {
+	contentUrl?: string;
+	publishedDate?: string;
+	managedContentChannelDetails: CmsChannelDetails;
+}
+
+export interface CmsSearchItem {
+	managedContentId: string;
+	managedContentKey: string;
+	title: string;
+	contentType: string;
+	language?: string;
+	highlightedSnippet?: string;
+	managedContentChannelDeliveryDetails: CmsChannelDeliveryDetails[];
+}
+
+export interface CmsSearchResponse {
+	total: number;
+	offset: number;
+	pageSize: number;
+	items: CmsSearchItem[];
+}
+
+/**
+ * Configuration for one CMS source in a search experience.
+ *
+ * Deliberately minimal — unlike an SObject source (which hardcodes an object
+ * name, searchable/display fields, filters, etc.), a CMS source hardcodes
+ * nothing about the CMS data. The search channel id comes from
+ * `searchChannel.getUIBundleId()`; content types are discovered at runtime from
+ * the search results. This config only names the source and (optionally)
+ * describes how to build a result link.
+ */
+export interface CmsSourceConfig {
+	/** Discriminator — selects the CMS runtime adapter. */
+	kind: "cms";
+	/**
+	 * Stable identifier. Used as the scope key, the result-map key, and the
+	 * prefix for CMS content-type scope entries (`"<key>:<fqn>"`). Must match
+	 * `/^[A-Za-z_][A-Za-z0-9_]*$/`.
+	 */
+	key: string;
+	/** Plural display label — dropdown entry + section header, e.g. "Content". */
+	label: string;
+	/** Singular label for the per-card source badge. Falls back to `label`. */
+	labelSingular?: string;
+	/**
+	 * Optional URL pattern used by `CmsResultRow` to build a result link.
+	 * Tokens: `:id` (managedContentId), `:key` (managedContentKey),
+	 * `:contentType` (contentType). When omitted, the row falls back to
+	 * `/content/:contentType/:id`.
+	 */
+	routePattern?: string;
+	// NO channelId, NO content types, NO displayFields — all resolved at runtime.
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/registry.ts

@@ -0,0 +1,38 @@
+/**
+ * Adapter registry — maps a source `kind` to its runtime {@link SourceAdapter}.
+ *
+ * The core query builder and response parser call {@link getAdapter} for each
+ * source instead of hard-coding SObject logic, so a new backend is added purely
+ * by registering an adapter here (plus its `kind` in the `SourceConfig` union).
+ *
+ * The `cmsAdapter` is authored by the CMS implementer at `./cms` (exported as
+ * `cmsAdapter`); it is imported and registered here, never stubbed.
+ */
+
+import type { SourceConfig } from "../types";
+import type { SourceAdapter } from "./types";
+import { sObjectAdapter } from "./sobject";
+import { cmsAdapter } from "./cms";
+
+/**
+ * Registry keyed by `SourceConfig["kind"]`. Each entry is the adapter narrowed
+ * to the matching config variant; `getAdapter` widens back to the base
+ * `SourceAdapter` for kind-agnostic callers.
+ */
+const REGISTRY: { [K in SourceConfig["kind"]]: SourceAdapter<Extract<SourceConfig, { kind: K }>> } =
+	{
+		sobject: sObjectAdapter,
+		cms: cmsAdapter,
+	};
+
+/**
+ * Returns the adapter registered for `kind`. Throws on an unknown kind (a
+ * config carrying a `kind` with no adapter is a programming error).
+ */
+export function getAdapter(kind: SourceConfig["kind"]): SourceAdapter {
+	const adapter = REGISTRY[kind];
+	if (!adapter) {
+		throw new Error(`No search adapter registered for source kind "${kind}".`);
+	}
+	return adapter as SourceAdapter;
+}

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/sobject/index.ts

@@ -0,0 +1,19 @@
+/**
+ * SObject adapter — the original uiapi GraphQL bridge, now behind the
+ * kind-agnostic {@link SourceAdapter} contract.
+ *
+ * `buildRequest` delegates to the extracted fragment builder and
+ * `parseResponse` to the extracted response parser. Both preserve the original
+ * behaviour byte-for-byte; this file is only the wiring.
+ */
+
+import type { SObjectSourceConfig } from "../../types";
+import type { SourceAdapter } from "../types";
+import { buildSObjectFragment } from "./queryFragment";
+import { parseSObjectResponse } from "./parseResponse";
+
+export const sObjectAdapter: SourceAdapter<SObjectSourceConfig> = {
+	kind: "sobject",
+	buildRequest: buildSObjectFragment,
+	parseResponse: parseSObjectResponse,
+};

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/adapters/sobject/parseResponse.ts

@@ -0,0 +1,56 @@
+/**
+ * SObject response parser.
+ *
+ * Extracted verbatim from `searchService.ts`: the `RawSourceResult` interface
+ * and the `edges → nodes / pageInfo / totalCount` mapping. Reads its subtree
+ * from `root.uiapi.query[source.key]` and returns `null` when the alias is
+ * absent (partial-failure leniency), never throwing.
+ */
+
+import type { SObjectSourceConfig, SourceResult } from "../../types";
+import type { SourceRequest } from "../types";
+
+interface RawSourceResult {
+	edges?: Array<{ node?: unknown }> | null;
+	pageInfo?: {
+		hasNextPage?: boolean | null;
+		hasPreviousPage?: boolean | null;
+		startCursor?: string | null;
+		endCursor?: string | null;
+	} | null;
+	totalCount?: number | null;
+}
+
+/**
+ * Maps `root.uiapi.query[source.key]` (an `edges`/`pageInfo`/`totalCount`
+ * subtree) to a {@link SourceResult}. Returns `null` when the alias is missing
+ * from the response (e.g. a partial GraphQL error blanked this source only).
+ */
+export function parseSObjectResponse(
+	root: Record<string, unknown>,
+	request: SourceRequest<SObjectSourceConfig>,
+): SourceResult | null {
+	const queryRoot = (root?.uiapi as Record<string, unknown> | undefined)?.query as
+		| Record<string, RawSourceResult | null | undefined>
+		| undefined;
+
+	const raw = queryRoot?.[request.source.key];
+	if (raw == null) return null;
+
+	const nodes = (raw.edges ?? [])
+		.map((edge) => edge?.node)
+		.filter((node): node is unknown => node != null);
+
+	return {
+		nodes,
+		pageInfo: raw.pageInfo
+			? {
+					hasNextPage: raw.pageInfo.hasNextPage ?? false,
+					hasPreviousPage: raw.pageInfo.hasPreviousPage ?? false,
+					startCursor: raw.pageInfo.startCursor ?? null,
+					endCursor: raw.pageInfo.endCursor ?? null,
+				}
+			: null,
+		totalCount: raw.totalCount ?? null,
+	};
+}