@vendure-platform/create 0.5.1 → 1.0.0-major.202609091053.0.0

package/dist/assets/storefront/src/i18n/server.ts

@@ -1,16 +1,44 @@
 import { hasLocale } from 'next-intl';
-import { getLocale } from 'next-intl/server';
+import { getLocale, setRequestLocale } from 'next-intl/server';
+import { locale as rootLocale } from 'next/root-params';
 import { routing, type Locale } from './routing';
 
 /**
- * Resolve the current locale from request context with validation.
+ * Resolve the current locale from the `[locale]` root param, with validation.
+ * Falls back to defaultLocale if the segment isn't in routing config.
+ *
+ * This is the default on the server, including 'use cache' scopes. Root params
+ * carry no request state, so a component that resolves the locale this way
+ * still prerenders.
+ */
+export async function getRootLocale(): Promise<Locale> {
+    const loc = await rootLocale();
+    return hasLocale(routing.locales, loc) ? (loc as Locale) : routing.defaultLocale;
+}
+
+/**
+ * Resolve the current locale from request context, with validation.
  * Falls back to defaultLocale if the resolved locale isn't in routing config.
  *
- * Use this in non-cached server components and server actions.
- * For 'use cache' scopes or route files (layout/page), prefer rootLocale()
- * from 'next/root-params' directly (the SWC transform only works in route files).
+ * Only for scopes root params cannot reach: Client Components, Server Actions
+ * and Route Handlers, plus server code that already renders dynamically.
+ * Reading request state blocks prerendering, so a Server Component that calls
+ * this serves no static shell — call `getRootLocale()` there instead.
  */
 export async function getRouteLocale(): Promise<Locale> {
     const loc = await getLocale();
     return hasLocale(routing.locales, loc) ? (loc as Locale) : routing.defaultLocale;
 }
+
+/**
+ * Pin the `[locale]` root param as next-intl's request locale.
+ *
+ * Call this before the first next-intl call in a Server Component that does not
+ * already pin the locale from `params`. Without it, `getTranslations()` resolves
+ * the locale through next-intl's request scope, which under `cacheComponents` is
+ * uncached request state: the route then fails `next build --debug-prerender`
+ * and serves no static shell.
+ */
+export async function pinRootLocale(): Promise<void> {
+    setRequestLocale(await getRootLocale());
+}

package/dist/assets/storefront/src/lib/backend-health.ts

@@ -10,12 +10,20 @@ const HEALTH_CHECK_TIMEOUT_MS = 3000;
  * on Vercel) but every API call fails, leaving the user with a branded but
  * empty shell. When this returns false we render a "Demo Paused" page instead.
  *
- * Cached for 15s (cacheLife('seconds')) so a stop/start of the backend is
- * reflected quickly without hammering the API on every request.
+ * This is cacheLife('seconds') with one field changed: `expire` goes from 60 to
+ * 300. The preset's 60s expire is too short for Next 16.3's build-time cache,
+ * which drops the entry between the cache-warming phase and the final prerender
+ * phase, and every prerendered page that mounts this gate then logs an
+ * "Unexpected cache miss" during `next build`. Measured on 16.3: expire 300 is
+ * retained, 120 is not.
+ *
+ * `stale` and `revalidate` keep the preset's values, so how fast a stop/start of
+ * the backend is picked up is unchanged. `expire` only bounds how long a stale
+ * value may be served when revalidation never runs.
  */
 export async function isBackendReachable(): Promise<boolean> {
     'use cache';
-    cacheLife('seconds');
+    cacheLife({ stale: 30, revalidate: 1, expire: 300 });
 
     const apiUrl = process.env.VENDURE_SHOP_API_URL || process.env.NEXT_PUBLIC_VENDURE_SHOP_API_URL;
     if (!apiUrl) return true;

package/dist/assets/storefront/src/lib/vendure/capability-documents.ts

@@ -0,0 +1,246 @@
+import { hasCapability } from '@/config/capabilities';
+import type {
+    DefinitionNode,
+    DocumentNode,
+    FieldNode,
+    FragmentDefinitionNode,
+    SelectionNode,
+    SelectionSetNode,
+} from 'graphql';
+import { visit } from 'graphql';
+
+/**
+ * A selection to drop, written as the path of field names from the operation
+ * root, e.g. `['product', 'customFields', 'configuratorSystemCode']`.
+ */
+export type FieldPath = readonly string[];
+
+export interface CapabilityDocumentRule {
+    capability: string;
+    paths: readonly FieldPath[];
+}
+
+export interface CapabilityDocumentRegistration<T extends DocumentNode = DocumentNode> {
+    name: string;
+    fullDocument: T;
+    rules: readonly CapabilityDocumentRule[];
+}
+
+/** Capability-owned storefront documents, used by the schema composition tests. */
+export const STOREFRONT_CAPABILITY_DOCUMENTS: CapabilityDocumentRegistration[] = [];
+
+function isField(selection: SelectionNode): selection is FieldNode {
+    return selection.kind === 'Field';
+}
+
+function fieldName(field: FieldNode): string {
+    return field.name.value;
+}
+
+function addOperationFallback<T extends DocumentNode>(document: T): T {
+    return {
+        ...document,
+        definitions: document.definitions.map((definition) => {
+            if (definition.kind !== 'OperationDefinition') return definition;
+            if (
+                definition.selectionSet.selections.some(
+                    (selection) => isField(selection) && fieldName(selection) === '__typename',
+                )
+            ) {
+                return definition;
+            }
+            return {
+                ...definition,
+                selectionSet: {
+                    ...definition.selectionSet,
+                    selections: [
+                        ...definition.selectionSet.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: '__typename' } },
+                    ],
+                },
+            };
+        }),
+    } as T;
+}
+
+function fragmentSpreads(selectionSet: SelectionSetNode): string[] {
+    const names: string[] = [];
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === 'FragmentSpread') {
+            names.push(selection.name.value);
+        } else if (selection.kind === 'Field' && selection.selectionSet) {
+            names.push(...fragmentSpreads(selection.selectionSet));
+        } else if (selection.kind === 'InlineFragment') {
+            names.push(...fragmentSpreads(selection.selectionSet));
+        }
+    }
+    return names;
+}
+
+function removeUnusedFragments(definitions: readonly DefinitionNode[]): readonly DefinitionNode[] {
+    const fragments = new Map<string, FragmentDefinitionNode>();
+    for (const definition of definitions) {
+        if (definition.kind === 'FragmentDefinition') {
+            fragments.set(definition.name.value, definition);
+        }
+    }
+
+    const used = new Set<string>();
+    const pending = definitions
+        .filter((definition) => definition.kind === 'OperationDefinition')
+        .flatMap((definition) => fragmentSpreads(definition.selectionSet));
+    while (pending.length > 0) {
+        const name = pending.pop()!;
+        if (used.has(name)) continue;
+        used.add(name);
+        const fragment = fragments.get(name);
+        if (fragment) pending.push(...fragmentSpreads(fragment.selectionSet));
+    }
+
+    return definitions.filter(
+        (definition) => definition.kind !== 'FragmentDefinition' || used.has(definition.name.value),
+    );
+}
+
+function removeUnusedVariables(definitions: readonly DefinitionNode[]): readonly DefinitionNode[] {
+    const used = new Set<string>();
+    visit({ kind: 'Document', definitions } as DocumentNode, {
+        VariableDefinition() {
+            return false;
+        },
+        Variable(node) {
+            used.add(node.name.value);
+        },
+    });
+
+    return definitions.map((definition) => {
+        if (definition.kind !== 'OperationDefinition' || !definition.variableDefinitions) {
+            return definition;
+        }
+        return {
+            ...definition,
+            variableDefinitions: definition.variableDefinitions.filter((variable) =>
+                used.has(variable.variable.name.value),
+            ),
+        };
+    });
+}
+
+/**
+ * Returns `selectionSet` with `path` removed, or `null` when removing it would
+ * leave an empty selection set — GraphQL has no syntax for one, so the caller
+ * drops the parent field instead.
+ */
+function stripPath(selectionSet: SelectionSetNode, path: FieldPath): SelectionSetNode | null {
+    const [head, ...rest] = path;
+    const selections: SelectionNode[] = [];
+
+    for (const selection of selectionSet.selections) {
+        if (!isField(selection) || fieldName(selection) !== head) {
+            selections.push(selection);
+            continue;
+        }
+        if (rest.length === 0) {
+            // Leaf reached: drop it by not re-adding it.
+            continue;
+        }
+        if (!selection.selectionSet) {
+            selections.push(selection);
+            continue;
+        }
+        const nested = stripPath(selection.selectionSet, rest);
+        if (nested) {
+            selections.push({ ...selection, selectionSet: nested });
+        }
+    }
+
+    return selections.length > 0 ? { ...selectionSet, selections } : null;
+}
+
+/**
+ * Removes capability-gated selections from a GraphQL document.
+ *
+ * The server composes its schema from the capability modules the deployment is
+ * entitled to, so selecting a field owned by an absent module fails validation
+ * on every request. Rather than maintaining a hand-written copy of each
+ * document per composition, the full document stays the single typed source of
+ * truth and the selections a composition cannot serve are pruned from it here.
+ *
+ * The returned document keeps the input's TypeScript type: a pruned field is
+ * `undefined` at runtime, so consumers must treat capability-gated data as
+ * optional. That is the same contract they already need for a field the server
+ * may legitimately return as null.
+ */
+export function stripCapabilityFields<T extends DocumentNode>(document: T, paths: FieldPath[]): T {
+    if (paths.length === 0) {
+        return document;
+    }
+    let definitions = document.definitions;
+    for (const path of paths) {
+        definitions = definitions.map((definition) => {
+            if (definition.kind !== 'OperationDefinition' && definition.kind !== 'FragmentDefinition') {
+                return definition;
+            }
+            const stripped = stripPath(definition.selectionSet, path);
+            if (!stripped) {
+                // Every selection collapsed, which GraphQL cannot express. A
+                // prune list that empties a whole operation is a mistake in the
+                // capability mapping, not something to paper over by keeping
+                // the field that was supposed to be removed.
+                throw new Error(
+                    `Pruning "${path.join('.')}" would leave an empty selection set. ` +
+                        'Split the document instead of pruning its only selection.',
+                );
+            }
+            return { ...definition, selectionSet: stripped };
+        });
+    }
+    const usedDefinitions = removeUnusedFragments(definitions);
+    return { ...document, definitions: removeUnusedVariables(usedDefinitions) } as T;
+}
+
+/**
+ * Convenience wrapper: prunes `paths` only when `granted` is false.
+ */
+export function whenGranted<T extends DocumentNode>(granted: boolean, document: T, paths: FieldPath[]): T {
+    return granted ? document : stripCapabilityFields(addOperationFallback(document), paths);
+}
+
+/**
+ * Registers and composes one typed storefront document from capability rules.
+ * The full typed document remains the source of truth. Missing grants prune
+ * only the selections that their modules own.
+ */
+export function composeCapabilityDocument<T extends DocumentNode>(
+    document: T,
+    rules: readonly CapabilityDocumentRule[],
+): T {
+    const operation = document.definitions.find((definition) => definition.kind === 'OperationDefinition');
+    const name = operation?.name?.value;
+    if (!name) {
+        throw new Error('Capability-composed storefront documents must use a named operation.');
+    }
+    STOREFRONT_CAPABILITY_DOCUMENTS.push({ name, fullDocument: document, rules });
+    return composeCapabilityDocumentFor(document, rules, (capability) => hasCapability(capability));
+}
+
+/** Compose a registered document for an explicit grant set in tests. */
+export function composeCapabilityDocumentFor<T extends DocumentNode>(
+    document: T,
+    rules: readonly CapabilityDocumentRule[],
+    granted: (capability: string) => boolean,
+): T {
+    return rules.reduce(
+        (composed, rule) => whenGranted(granted(rule.capability), composed, [...rule.paths]),
+        document,
+    );
+}
+
+/** Registers a document owned by one capability. */
+export function forCapability<T extends DocumentNode>(
+    capability: string,
+    document: T,
+    paths: readonly FieldPath[],
+): T {
+    return composeCapabilityDocument(document, [{ capability, paths }]);
+}

package/dist/assets/storefront/src/lib/vendure/capability-schema.ts

@@ -0,0 +1,358 @@
+import {
+    buildSchema,
+    Kind,
+    parse,
+    print,
+    type DefinitionNode,
+    type DocumentNode,
+    type GraphQLSchema,
+    type InputObjectTypeDefinitionNode,
+    type InterfaceTypeDefinitionNode,
+    type ObjectTypeDefinitionNode,
+} from 'graphql';
+
+/** A capability-owned type, or a field on an otherwise shared type. */
+export interface SchemaContribution {
+    /** Whole types the module adds to the schema. */
+    types?: readonly string[];
+    /** Fields the module adds to a type it shares with other modules. */
+    fields?: Readonly<Record<string, readonly string[]>>;
+}
+
+/**
+ * The two configurator schema sections, mirroring
+ * `libs/configurator/src/api/api-extensions.ts`. Removing both sections from
+ * the full schema reproduces a deployment without the configurator grant.
+ */
+export const CONFIGURATOR_FORMS_CONTRIBUTION: SchemaContribution = {
+    types: [
+        'FieldType',
+        'ConfiguratorField',
+        'ConfiguratorFieldTranslation',
+        'ConfiguratorFieldOption',
+        'ConfiguratorFieldOptionTranslation',
+        'ConfiguratorModule',
+        'ConfiguratorModuleTranslation',
+        'ConfiguratorSystem',
+        'ConfiguratorSystemTranslation',
+        'ProductConfiguration',
+        'ProductConfigurationFieldValue',
+        'ProductConfigurationEvaluation',
+        'EvaluatedField',
+        'EvaluatedFieldOption',
+        'EvaluatedFieldMessage',
+        'ConfiguratorValueInput',
+        'EvaluateProductConfigurationInput',
+        'AddProductConfigurationToOrderInput',
+        'UpdateProductConfigurationOnOrderInput',
+    ],
+    fields: {
+        Query: ['configuratorSystem', 'configuratorSystems', 'evaluateProductConfiguration'],
+        Mutation: [
+            'addProductConfigurationToOrder',
+            'updateProductConfigurationOnOrder',
+            'removeProductConfigurationFromOrder',
+        ],
+        Order: ['productConfigurations'],
+        OrderLineCustomFields: ['productConfiguration', 'productConfigurationId'],
+        ProductCustomFields: ['configuratorSystemCode'],
+        ProductFilterParameter: ['configuratorSystemCode'],
+        ProductSortParameter: ['configuratorSystemCode'],
+    },
+};
+
+export const CONFIGURATOR_RULES_CONTRIBUTION: SchemaContribution = {
+    types: [
+        'ProductConfigurationLine',
+        'EvaluatedProductConfigurationLine',
+        'ProductConfigurationEvaluationTotals',
+        'CalculationError',
+        'ExecutedRule',
+    ],
+    fields: {
+        ProductConfigurationEvaluation: ['lines', 'errors', 'executedRules', 'totals'],
+        ProductConfiguration: ['lines'],
+        OrderLineCustomFields: ['productConfigurationLine', 'productConfigurationLineId'],
+    },
+};
+
+/** Shop API fields contributed by capability modules used in storefront documents. */
+export const STOREFRONT_CAPABILITY_CONTRIBUTIONS: Readonly<Record<string, SchemaContribution>> = {
+    'org.accounts': {
+        fields: {
+            Query: [
+                'activeCompanyUser',
+                'companyAccount',
+                'shopCompanyUsers',
+                'companyRoles',
+                'companyAddresses',
+                'companyPaymentMethods',
+                'companyInvitation',
+                'companyOrders',
+            ],
+            Mutation: [
+                'registerCompany',
+                'updateCompanyAccount',
+                'createCompanyAddress',
+                'updateCompanyAddress',
+                'deleteCompanyAddress',
+                'inviteCompanyUser',
+                'updateCompanyUser',
+                'removeCompanyUser',
+                'assignCompanyUserRole',
+                'acceptCompanyInvitation',
+            ],
+            Customer: ['companyUsers'],
+        },
+    },
+    'org.hierarchy': {
+        fields: {
+            Query: ['companyBusinessUnits'],
+            Mutation: [
+                'createCompanyBusinessUnit',
+                'updateCompanyBusinessUnit',
+                'deleteCompanyBusinessUnit',
+                'switchBusinessUnit',
+            ],
+            Company: ['businessUnits'],
+            CompanyAccount: ['activeBusinessUnit'],
+            CompanyUser: ['businessUnits'],
+            CompanyAddress: ['businessUnit'],
+            CreateCompanyAddressShopInput: ['businessUnitId'],
+            UpdateCompanyAddressShopInput: ['businessUnitId'],
+            InviteCompanyUserInput: ['businessUnitIds'],
+            UpdateCompanyUserShopInput: ['businessUnitIds'],
+        },
+    },
+    'tax-id.validation': {
+        fields: {
+            Query: ['taxIds'],
+            Mutation: ['addTaxId', 'removeTaxId', 'setDefaultTaxId'],
+        },
+    },
+    'quote.requests': {
+        fields: {
+            Query: ['myQuotes', 'myQuote', 'quoteStockCheck'],
+            Mutation: [
+                'requestQuote',
+                'requestQuoteFromCart',
+                'submitQuoteRequest',
+                'acceptQuote',
+                'rejectQuote',
+                'acceptAndConvertQuote',
+                'cancelQuoteCheckout',
+            ],
+            OrderCustomFields: ['sourceQuoteId'],
+            OrderFilterParameter: ['sourceQuoteId'],
+            OrderSortParameter: ['sourceQuoteId'],
+        },
+    },
+    'quote.negotiation': {
+        fields: {
+            Mutation: ['requestQuoteChanges', 'addQuoteComment'],
+            Quote: ['comments', 'versions'],
+        },
+    },
+    'shopping-list.personal': {
+        fields: {
+            Query: ['activeUserShoppingList', 'activeUserShoppingLists'],
+            Mutation: [
+                'addToShoppingList',
+                'removeFromShoppingList',
+                'updateShoppingListItem',
+                'createShoppingList',
+                'updateShoppingList',
+                'deleteShoppingList',
+                'addShoppingListItemsToOrder',
+                'moveShoppingListItems',
+            ],
+            ProductVariant: ['appearsInShoppingLists'],
+        },
+    },
+    'shopping-list.managed': {
+        fields: {
+            Query: ['publicShoppingList'],
+            Mutation: ['setShoppingListVisibility'],
+            ShoppingList: ['isPublic', 'publicCode', 'customer'],
+            ShoppingListItem: ['purchased', 'lastPurchasedAt'],
+        },
+    },
+    'quick-order': {
+        fields: {
+            Query: ['quickOrderSearch'],
+            Mutation: ['validateQuickOrderItems', 'addQuickOrderItemsToOrder'],
+        },
+    },
+    reorder: {
+        fields: {
+            Query: ['previewReorder'],
+            Mutation: ['addReorderToActiveOrder'],
+        },
+    },
+    'store-credit.balance': {
+        fields: {
+            Query: ['myStoreCredits'],
+            Mutation: [
+                'applyStoreCreditToOrder',
+                'removeStoreCreditFromOrder',
+                'claimStoreCredit',
+                'addPaymentToOrderWithStoreCredit',
+            ],
+            Order: ['storeCreditsApplied', 'totalWithTaxAfterStoreCredit'],
+        },
+    },
+    'store-credit.gift-cards': {
+        fields: {
+            Query: ['giftCardTemplates'],
+            Mutation: ['addGiftCardToOrder'],
+            OrderLine: ['giftCardInput'],
+            ProductCustomFields: ['isGiftCard'],
+            ProductFilterParameter: ['isGiftCard'],
+            ProductSortParameter: ['isGiftCard'],
+        },
+    },
+    'packaging-units': {
+        fields: {
+            ProductVariant: ['packagingUnits'],
+            OrderLineCustomFields: ['packagingUnit', 'packagingUnitConversionFactor'],
+            OrderLineCustomFieldsInput: [
+                'packagingUnitId',
+                'packagingUnitConversionFactor',
+                'packagingUnitName',
+            ],
+        },
+    },
+    'shared-carts.collaboration': {
+        fields: {
+            Query: ['mySharedCarts', 'sharedCart', 'companySharedCarts'],
+            Mutation: [
+                'createSharedCart',
+                'updateSharedCart',
+                'deleteSharedCart',
+                'addItemToSharedCart',
+                'adjustSharedCartLine',
+                'removeSharedCartLine',
+                'addSharedCartMember',
+                'removeSharedCartMember',
+                'setSharedCartMemberRole',
+                'transferSharedCartOwnership',
+                'initiateSharedCartCheckout',
+            ],
+        },
+    },
+    'content.history': { fields: { Query: ['contentVersioningProductVariant'] } },
+    'approval.orders': {
+        fields: {
+            Query: ['myApprovalRequests', 'approvalHistoryForEntity'],
+            Mutation: ['submitApprovalDecision', 'batchSubmitApprovalDecisions'],
+        },
+    },
+    'pricing.contract': {
+        fields: {
+            ProductVariant: ['priceTiers'],
+            ShopProductVariantPackagingUnit: ['priceTiers'],
+        },
+    },
+    'search.foundation': {
+        fields: {
+            Query: ['searchCollections'],
+            SearchResult: ['highlights'],
+        },
+    },
+    'search.analytics.clickhouse': {
+        fields: {
+            Mutation: ['logSearchListViewed', 'logSearchResultClicked'],
+            SearchResponse: ['queryId'],
+        },
+    },
+    'configurator.forms': {
+        fields: {
+            ...CONFIGURATOR_FORMS_CONTRIBUTION.fields,
+            ...CONFIGURATOR_RULES_CONTRIBUTION.fields,
+            OrderLineCustomFields: [
+                'productConfiguration',
+                'productConfigurationId',
+                'productConfigurationLine',
+                'productConfigurationLineId',
+            ],
+        },
+    },
+    punchout: {
+        fields: {
+            Query: ['activePunchoutSession'],
+            Mutation: ['activatePunchoutSession', 'transferPunchoutCart'],
+            AuthenticationInput: ['punchout'],
+            ProductCustomFields: ['unspscCode'],
+            ProductFilterParameter: ['unspscCode'],
+            ProductSortParameter: ['unspscCode'],
+        },
+    },
+};
+
+/** Build the Shop API schema for an explicit grant set. */
+export function buildSchemaForCapabilities(fullSdl: string, grants: ReadonlySet<string>): GraphQLSchema {
+    return buildSchemaWithout(
+        fullSdl,
+        Object.entries(STOREFRONT_CAPABILITY_CONTRIBUTIONS)
+            .filter(([capability]) => !grants.has(capability))
+            .map(([, contribution]) => contribution),
+    );
+}
+
+function removeContribution(document: DocumentNode, contribution: SchemaContribution): DocumentNode {
+    const droppedTypes = new Set(contribution.types ?? []);
+    const droppedFields = contribution.fields ?? {};
+
+    const definitions: DefinitionNode[] = [];
+    for (const definition of document.definitions) {
+        if (!('name' in definition) || !definition.name) {
+            definitions.push(definition);
+            continue;
+        }
+        const typeName = definition.name.value;
+        if (droppedTypes.has(typeName)) {
+            continue;
+        }
+        const fieldsToDrop = droppedFields[typeName];
+        if (!fieldsToDrop) {
+            definitions.push(definition);
+            continue;
+        }
+        if (
+            definition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+            definition.kind === Kind.INTERFACE_TYPE_DEFINITION
+        ) {
+            const node = definition as ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
+            definitions.push({
+                ...node,
+                fields: (node.fields ?? []).filter((field) => !fieldsToDrop.includes(field.name.value)),
+            });
+            continue;
+        }
+        if (definition.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+            const node = definition as InputObjectTypeDefinitionNode;
+            definitions.push({
+                ...node,
+                fields: (node.fields ?? []).filter((field) => !fieldsToDrop.includes(field.name.value)),
+            });
+            continue;
+        }
+        definitions.push(definition);
+    }
+    return { ...document, definitions };
+}
+
+/**
+ * Builds the Shop API schema a deployment serves when the listed capability
+ * contributions are absent.
+ */
+export function buildSchemaWithout(
+    fullSdl: string,
+    contributions: readonly SchemaContribution[],
+): GraphQLSchema {
+    let document = parse(fullSdl);
+    for (const contribution of contributions) {
+        document = removeContribution(document, contribution);
+    }
+    return buildSchema(print(document));
+}

package/dist/assets/storefront/src/lib/vendure/capability-ui.ts

@@ -0,0 +1,15 @@
+/** Makes capability-pruned quote activity safe for UI consumers. */
+export function getQuoteNegotiationData<Comment, Version>(quote: {
+    comments?: Comment[];
+    versions?: Version[];
+}): { comments: Comment[]; versions: Version[] } {
+    return {
+        comments: quote.comments ?? [],
+        versions: quote.versions ?? [],
+    };
+}
+
+/** Makes capability-pruned search highlights safe for product cards. */
+export function getSearchHighlights<Highlight>(product: { highlights?: Highlight[] }): Highlight[] {
+    return product.highlights ?? [];
+}