@salesforce/templates 66.17.5 → 66.18.0

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "base-vue-app",
+  "private": true,
+  "version": "1.59.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "dev": "vite",
+    "dev:design": "vite --mode design",
+    "build": "vue-tsc -b && vite build",
+    "build:e2e": "npm run build && node scripts/rewrite-e2e-assets.mjs",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "test": "vitest",
+    "graphql:codegen": "graphql-codegen",
+    "graphql:schema": "node scripts/get-graphql-schema.mjs"
+  },
+  "dependencies": {
+    "@lucide/vue": "^1.47.0",
+    "@salesforce/platform-sdk": "^12.14.0",
+    "@salesforce/ui-bundle": "^12.14.0",
+    "@tailwindcss/vite": "^4.1.17",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "date-fns": "^4.1.0",
+    "reka-ui": "^2.5.0",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.1.17",
+    "tw-animate-css": "^1.4.0",
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.0",
+    "vue-sonner": "^2.0.0",
+    "@salesforce/agentforce-conversation-client": "^12.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@graphql-codegen/cli": "^6.1.0",
+    "@graphql-codegen/typescript": "^5.0.6",
+    "@graphql-codegen/typescript-operations": "^5.0.6",
+    "@graphql-eslint/eslint-plugin": "^4.1.0",
+    "@graphql-tools/utils": "^11.0.0",
+    "@playwright/test": "^1.49.0",
+    "@salesforce/graphiti": "^12.14.0",
+    "@salesforce/vite-plugin-ui-bundle": "^12.14.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/user-event": "^14.5.2",
+    "@testing-library/vue": "^8.1.0",
+    "@types/node": "^24.10.1",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "@vitest/ui": "^4.1.0",
+    "@vue/eslint-config-typescript": "^14.1.4",
+    "@vue/test-utils": "^2.4.6",
+    "eslint": "^9.39.1",
+    "eslint-plugin-vue": "^9.32.0",
+    "globals": "^16.5.0",
+    "graphql": "^16.11.0",
+    "graphql-codegen-typescript-operation-types": "^2.0.2",
+    "jsdom": "^25.0.1",
+    "serve": "^14.2.5",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.71.2",
+    "vite": "^7.2.4",
+    "vite-plugin-graphql-codegen": "^3.6.3",
+    "vitest": "^4.1.0",
+    "vue-tsc": "^2.2.0"
+  },
+  "overrides": {
+    "lodash": "^4.18.1",
+    "undici": "^7.28.0"
+  }
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/playwright.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig, devices } from '@playwright/test';
+
+const E2E_PORT = 5177;
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    baseURL: `http://localhost:${E2E_PORT}`,
+    trace: 'on-first-retry',
+  },
+  projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],
+  webServer: {
+    // Serve built dist/ with static server so e2e works in CI without SF org (vite preview runs plugin and can fail)
+    command: `npx serve dist -l ${E2E_PORT}`,
+    url: `http://localhost:${E2E_PORT}`,
+    reuseExistingServer: !process.env.CI,
+    timeout: process.env.CI ? 120_000 : 60_000,
+  },
+});

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/scripts/get-graphql-schema.mjs

@@ -0,0 +1,71 @@
+/**
+ * Downloads the full GraphQL schema from a connected Salesforce org via introspection.
+ *
+ * Usage:
+ *   npm run graphql:schema
+ *   node scripts/get-graphql-schema.mjs [output-path]
+ *
+ * The default output path matches the schema location expected by codegen.yml
+ * and .graphqlrc.yml so that codegen and IDE tooling resolve it automatically.
+ */
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getOrgInfo } from '@salesforce/ui-bundle/app';
+import { buildClientSchema, getIntrospectionQuery, printSchema } from 'graphql';
+import { pruneSchema } from '@graphql-tools/utils';
+
+const DEFAULT_SCHEMA_PATH = '../../../../../schema.graphql';
+const TARGET_ORG = process.env.SF_TARGET_ORG || undefined;
+
+async function executeSalesforceGraphQLQuery(query, variables, operationName) {
+  const orgInfo = await getOrgInfo(TARGET_ORG);
+  if (!orgInfo) {
+    throw new Error(
+      'Could not resolve a Salesforce org. Set SF_TARGET_ORG or a default org.'
+    );
+  }
+  const { rawInstanceUrl: instanceUrl, apiVersion, accessToken } = orgInfo;
+
+  const targetUrl = `${instanceUrl}/services/data/v${apiVersion}/graphql`;
+
+  console.log(`Executing introspection query against ${targetUrl}`);
+  const response = await fetch(targetUrl, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+      'X-Chatter-Entity-Encoding': 'false',
+    },
+    body: JSON.stringify({ query, variables, operationName }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Salesforce GraphQL request failed: ${response.status} ${response.statusText} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}
+
+try {
+  const outputPath = resolve(process.argv[2] || DEFAULT_SCHEMA_PATH);
+
+  const introspectionResult = await executeSalesforceGraphQLQuery(
+    getIntrospectionQuery(),
+    {},
+    'IntrospectionQuery'
+  );
+
+  const schema = buildClientSchema(introspectionResult.data);
+  const prunedSchema = pruneSchema(schema);
+  const sdl = printSchema(prunedSchema);
+
+  writeFileSync(outputPath, sdl);
+
+  console.log(`Schema saved to ${outputPath}`);
+} catch (error) {
+  console.error('Error:', error.message);
+  process.exit(1);
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/scripts/rewrite-e2e-assets.mjs

@@ -0,0 +1,23 @@
+/**
+ * Prepares dist/ for e2e: root-relative asset paths + SPA fallback for serve.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const distDir = join(__dirname, '..', 'dist');
+
+// Rewrite index.html so asset paths are root-relative (/assets/...)
+const indexPath = join(distDir, 'index.html');
+let html = readFileSync(indexPath, 'utf8');
+html = html.replace(/(src|href)="[^"]*\/assets\//g, '$1="/assets/');
+writeFileSync(indexPath, html);
+
+// SPA fallback so /about, /non-existent-route etc. serve index.html
+writeFileSync(
+  join(distDir, 'serve.json'),
+  JSON.stringify({
+    rewrites: [{ source: '**', destination: '/index.html' }],
+  })
+);

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/App.vue

@@ -0,0 +1,5 @@
+<script setup lang="ts"></script>
+
+<template>
+  <RouterView />
+</template>

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/_f_/search/adapters/cms/api/apiUtils.ts

@@ -0,0 +1,56 @@
+/**
+ * Self-contained CMS Connect REST helpers (URL builder + authenticated GET).
+ */
+
+import { createDataSDK } from "@salesforce/platform-sdk";
+
+// The build injects the org's API version via `__SF_API_VERSION__`; the literal
+// is only a fallback for environments (e.g. unit tests) where it is undefined.
+declare const __SF_API_VERSION__: string;
+
+/** Project-standard API version, mirroring `@salesforce/ui-bundle/api`'s clients. */
+const API_VERSION: string = typeof __SF_API_VERSION__ !== "undefined" ? __SF_API_VERSION__ : "65.0";
+
+/**
+ * The bundle's build-time API version as a number (e.g. `68.0`), i.e. the
+ * version the SDK's GraphQL/REST requests are actually issued at. `0` when it
+ * cannot be parsed. Distinct from the org's advertised max version.
+ */
+export function getBuildApiVersion(): number {
+	const v = Number.parseFloat(API_VERSION);
+	return Number.isFinite(v) ? v : 0;
+}
+
+/**
+ * Percent-encodes a single path segment (SSRF / path-injection guard). Mirrors
+ * the reference `safeEncodePath`.
+ */
+export function safeEncodePath(segment: string): string {
+	return encodeURIComponent(segment);
+}
+
+/** Builds an absolute Connect REST URL from a version-relative sub-path. */
+export function connectUrl(subPath: string): string {
+	const normalized = subPath.startsWith("/") ? subPath : `/${subPath}`;
+	return `/services/data/v${API_VERSION}/connect${normalized}`;
+}
+
+/**
+ * GETs a Connect JSON resource via the platform SDK's authenticated `fetch`
+ * and returns the parsed body. Throws on SDK-init failure or a non-OK response
+ * (the caller decides how a whole-request failure surfaces).
+ */
+export async function connectGetJson<T = unknown>(url: string): Promise<T> {
+	const sdk = await createDataSDK();
+	if (!sdk?.fetch) {
+		throw new Error("Failed to initialize data SDK for CMS REST call");
+	}
+	const response = await sdk.fetch(url, {
+		method: "GET",
+		headers: { Accept: "application/json" },
+	});
+	if (!response.ok) {
+		throw new Error(`CMS REST request failed: ${response.status} ${response.statusText}`);
+	}
+	return (await response.json()) as T;
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/_f_/search/adapters/cms/api/orgApiVersionService.ts

@@ -0,0 +1,37 @@
+/** Service to gate CMS search on the bundle's build-time API version. */
+
+import { getBuildApiVersion } from "./apiUtils";
+
+/** Minimum API version that supports CMS search. */
+export const MIN_CMS_API_VERSION = 68;
+
+/**
+ * Whether CMS search can run — the synchronous core of the gate. Gated on the
+ * bundle's build-time API version (`__SF_API_VERSION__`, injected from the
+ * resolved org's API version at build time) being >= {@link MIN_CMS_API_VERSION}.
+ *
+ * The build version is the version every SDK GraphQL/REST request is actually
+ * issued at, so it already reflects a concrete, org-supported API version: a
+ * bundle built against an org resolves that org's max version, and a bundle
+ * built below v68 sends its CMS query to `/services/data/v67.0/graphql` where
+ * the v68 CMS backend is unavailable. Gating on the build version alone is
+ * therefore both necessary and sufficient — and, unlike a runtime probe of the
+ * bare `/services/data/` version-listing endpoint (which is not routed on guest
+ * Experience Sites and would fail-close there), it works on every surface.
+ *
+ * Because it reads only the baked build version, it is safe to call during
+ * render — e.g. to hide the CMS source's scope entry and result section when
+ * the backend isn't available (see `ScopeSelector` and `SearchResults`).
+ */
+export function isCmsSearchSupported(): boolean {
+	return getBuildApiVersion() >= MIN_CMS_API_VERSION;
+}
+
+/**
+ * Resolves whether CMS search can run. Thin async wrapper over
+ * {@link isCmsSearchSupported} that preserves the existing fetch-path call-site
+ * contract (the fetch effect awaits it alongside the async UIBundle-id lookup).
+ */
+export function getOrgSupportsCmsSearch(): Promise<boolean> {
+	return Promise.resolve(isCmsSearchSupported());
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/_f_/search/adapters/cms/api/searchableContentTypesService.ts

@@ -0,0 +1,119 @@
+/**
+ * Connect REST caller for a CMS channel's searchable content types:
+ *   GET /connect/cms/channels/{channelId}/searchable-content-types?page=N&pageSize=25
+ * Returns the validated content types (FQN + server label) that populate the
+ * content-type scope entries.
+ */
+
+import { connectGetJson, connectUrl, safeEncodePath } from "./apiUtils";
+import {
+	isValidCmsFqn,
+	formatContentTypeLabel,
+	type DiscoveredContentType,
+} from "../contentTypeUtils";
+
+/** Hard-coded REST page size. NEVER user input. */
+const REST_PAGE_SIZE = 25;
+
+/** Safety cap so a misbehaving backend cannot spin an unbounded loop. */
+const MAX_PAGES = 100;
+
+/** Channel id shape guard — `0ap` + 12–15 alphanumerics — validates the discovery channel id before the searchable-content-types REST call. */
+export const CHANNEL_ID_PATTERN = /^0ap[a-zA-Z0-9]{12,15}$/;
+
+/** One raw entry from the Connect response. */
+interface RawContentTypeEntry {
+	/** FQN with the `sfdc_cms__` prefix (e.g. "sfdc_cms__news"). */
+	id?: string;
+	/** Server-provided display name (e.g. "News"). */
+	label?: string;
+	/** Bare developer name without the prefix (e.g. "news"). */
+	name?: string;
+	// Legacy/alternate FQN field names kept as fallbacks.
+	contentType?: string;
+	fqn?: string;
+	developerName?: string;
+	isSearchable?: boolean;
+	searchable?: boolean;
+}
+
+/** Loose shape of one page of the Connect response. */
+interface RawContentTypesPage {
+	items?: RawContentTypeEntry[];
+	contentTypes?: RawContentTypeEntry[];
+}
+
+/** Reads the entries array from a page payload (array or object form). */
+function pageItems(payload: unknown): RawContentTypeEntry[] {
+	if (Array.isArray(payload)) return payload as RawContentTypeEntry[];
+	const obj = payload as RawContentTypesPage | null;
+	if (obj?.items && Array.isArray(obj.items)) return obj.items;
+	if (obj?.contentTypes && Array.isArray(obj.contentTypes)) return obj.contentTypes;
+	return [];
+}
+
+/** True when the entry is not explicitly marked non-searchable. */
+function isSearchable(entry: RawContentTypeEntry): boolean {
+	if (typeof entry.isSearchable === "boolean") return entry.isSearchable;
+	if (typeof entry.searchable === "boolean") return entry.searchable;
+	// No flag present → do not exclude on searchability (FQN validity still gates).
+	return true;
+}
+
+/** ManagedContentType key prefix — the `id` custom content types carry instead of an FQN. */
+const CONTENT_TYPE_RECORD_ID_PATTERN = /^0T1[a-zA-Z0-9]{12,15}$/;
+
+/** Extracts the prefixed FQN from an entry, rebuilding `c__<name>` when `id` is a custom-type record id. */
+function entryFqn(entry: RawContentTypeEntry): string | undefined {
+	// Custom types put a ManagedContentType id in `id`; the FQN the GraphQL filter
+	// accepts is `c__<name>`.
+	if (entry.id && CONTENT_TYPE_RECORD_ID_PATTERN.test(entry.id)) {
+		return entry.name ? `c__${entry.name}` : undefined;
+	}
+	return entry.id ?? entry.contentType ?? entry.fqn ?? entry.developerName;
+}
+
+/**
+ * Fetches every searchable content type for `channelId`, paginating the
+ * Connect endpoint until a short page is returned, then filtering to searchable
+ * entries whose FQN passes `isValidCmsFqn`. Each result carries the FQN and the
+ * server-provided display `label` (falling back to a derived label only when
+ * the response omits one). De-duplicates by FQN, preserving first-seen order.
+ *
+ * @throws when `channelId` fails the shape guard (before any network call).
+ */
+export async function fetchSearchableContentTypes(
+	channelId: string,
+): Promise<DiscoveredContentType[]> {
+	if (!CHANNEL_ID_PATTERN.test(channelId)) {
+		throw new Error(`Invalid CMS channel id "${channelId}".`);
+	}
+
+	const encoded = safeEncodePath(channelId);
+	const collected: DiscoveredContentType[] = [];
+	const seen = new Set<string>();
+
+	for (let page = 0; page < MAX_PAGES; page++) {
+		const url = connectUrl(
+			`/cms/channels/${encoded}/searchable-content-types?page=${page}&pageSize=${REST_PAGE_SIZE}`,
+		);
+		const payload = await connectGetJson(url);
+		const items = pageItems(payload);
+
+		for (const entry of items) {
+			const fqn = entryFqn(entry);
+			if (!fqn || !isSearchable(entry) || !isValidCmsFqn(fqn) || seen.has(fqn)) {
+				continue;
+			}
+			seen.add(fqn);
+			// Prefer the server label; fall back to a label derived from the FQN.
+			const label = entry.label?.trim() || formatContentTypeLabel(fqn);
+			collected.push({ fqn, label });
+		}
+
+		// Last page reached when fewer than a full page came back.
+		if (items.length < REST_PAGE_SIZE) break;
+	}
+
+	return collected;
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/_f_/search/adapters/cms/channelResolver.ts

@@ -0,0 +1,40 @@
+/**
+ * Extracts the CMS channel id from a search result so it can feed the
+ * searchable-content-types Connect endpoint. There is one CMS channel for the
+ * app, so any result carries it:
+ *
+ *   nodes[0].managedContentChannelDeliveryDetails[0].managedContentChannelDetails.id
+ *
+ * Returns `null` when any hop is missing (empty nodes, missing delivery
+ * details, missing channel details / id) — the caller simply skips discovery.
+ */
+
+import type { SourceResult } from "../../types";
+import type { CmsSearchResponse, CmsSearchItem } from "./types";
+
+/** Accepts either a normalised `SourceResult` or a raw `CmsSearchResponse`. */
+type ChannelSource = SourceResult | CmsSearchResponse | null | undefined;
+
+function getNodes(result: ChannelSource): unknown[] {
+	if (!result) return [];
+	// SourceResult carries `nodes`; CmsSearchResponse carries `items`.
+	if ("nodes" in result && Array.isArray(result.nodes)) return result.nodes;
+	if ("items" in result && Array.isArray(result.items)) return result.items;
+	return [];
+}
+
+/**
+ * Returns the channel id derived from the first result's delivery details, or
+ * `null` when any level is absent. Validate the returned id's shape before it
+ * enters a REST path (the discovery service does this).
+ */
+export function resolveChannelId(result: ChannelSource): string | null {
+	const nodes = getNodes(result);
+	const first = nodes[0] as Partial<CmsSearchItem> | undefined;
+	if (!first) return null;
+
+	const delivery = first.managedContentChannelDeliveryDetails?.[0];
+	const id = delivery?.managedContentChannelDetails?.id;
+
+	return typeof id === "string" && id.length > 0 ? id : null;
+}

package/lib/templates/project/vueinternalapp/_p_/_m_/_w_/_a_/src/_f_/search/adapters/cms/cmsQueryFragment.ts

@@ -0,0 +1,108 @@
+/**
+ * Builds the CMS `managed_content { search { searchContentInChannels … } }`
+ * fragment as a {@link QueryFragmentContribution} with `placement: "root"` — a
+ * sibling of the `uiapi` block in the combined document.
+ *
+ * The `$cmsContentTypeFQNs` declaration, its `contentTypeFQNs:` argument, and
+ * its variable value are all emitted only when a non-empty content-type list is
+ * passed; on the bootstrap call (no types known) they are omitted entirely. The
+ * `$cmsLanguage` pieces follow the same conditional pattern.
+ */
+
+import type { QueryFragmentContribution } from "../types";
+
+export interface BuildCmsFragmentParams {
+	/** Search keyword → `$cmsKeyword`. */
+	keyword: string;
+	/** UIBundle Id fed into the query → `$UIBundleId` (from `getUIBundleId()`). */
+	uiBundleId: string;
+	/** Pagination offset → `$cmsOffset` (already clamped `>= 0` by the caller). */
+	offset: number;
+	/** Page size → `$cmsLimit` (validated against `pageSizeOptions` upstream). */
+	limit: number;
+	/**
+	 * Discovered/selected content-type FQNs → the schema's `contentTypeFQNs`
+	 * argument (via `$cmsContentTypeFQNs`). When absent, null, or empty, those
+	 * pieces are omitted entirely (bootstrap call). Callers pass ONLY
+	 * `isValidCmsFqn`-validated values.
+	 */
+	contentTypes?: string[] | null;
+	/** User language tag for the `language` argument; emitted only when a non-empty string. */
+	language?: string | null;
+}
+
+/**
+ * Builds the CMS fragment contribution. The content-type filter pieces are
+ * included only when `params.contentTypes` is a non-empty array.
+ */
+export function buildCmsQueryFragment(params: BuildCmsFragmentParams): QueryFragmentContribution {
+	const { keyword, uiBundleId, offset, limit, contentTypes, language } = params;
+
+	const hasContentTypes = Array.isArray(contentTypes) && contentTypes.length > 0;
+	const hasLanguage = typeof language === "string" && language.length > 0;
+
+	const variableDeclarations = [
+		"$cmsKeyword: String!",
+		"$UIBundleId: ID!",
+		"$cmsOffset: Int!",
+		"$cmsLimit: Int!",
+	];
+
+	const variables: Record<string, unknown> = {
+		cmsKeyword: keyword,
+		UIBundleId: uiBundleId,
+		cmsOffset: offset,
+		cmsLimit: limit,
+	};
+
+	// CONDITIONAL: declare + pass + supply the content-type filter only when a
+	// non-empty list is provided. Otherwise these three pieces are all absent.
+	// The schema argument is `contentTypeFQNs` (a list of content-type FQNs) —
+	// NOT `contentTypes`; the latter is rejected as an unknown field argument.
+	const contentTypesArg = hasContentTypes ? "\n          contentTypeFQNs: $cmsContentTypeFQNs" : "";
+	if (hasContentTypes) {
+		variableDeclarations.push("$cmsContentTypeFQNs: [String!]");
+		variables.cmsContentTypeFQNs = contentTypes;
+	}
+
+	// Top-level `language: String` arg, emitted only when a non-empty tag is provided.
+	const languageArg = hasLanguage ? "\n          language: $cmsLanguage" : "";
+	if (hasLanguage) {
+		variableDeclarations.push("$cmsLanguage: String");
+		variables.cmsLanguage = language;
+	}
+
+	const fragment = `managed_content {
+  search {
+    searchContentInChannels(
+      searchIdentifiers: { uibundleIds: [$UIBundleId] }
+      keyword: $cmsKeyword
+      pagination: { limit: $cmsLimit, offset: $cmsOffset }${languageArg}${contentTypesArg}
+    ) {
+      total
+      offset
+      pageSize
+      items {
+        managedContentId
+        managedContentKey
+        title
+        contentType
+        language
+        highlightedSnippet
+        managedContentChannelDeliveryDetails {
+          contentUrl
+          publishedDate
+          managedContentChannelDetails { id name type }
+        }
+      }
+    }
+  }
+}`;
+
+	return {
+		variableDeclarations,
+		variables,
+		placement: "root",
+		fragment,
+	};
+}