@coveo/headless 3.29.1 → 3.29.2-pre.027eeece31

package/dist/esm/ssr-next/commerce/utils/controller-wiring.js

@@ -1,4 +1,162 @@
-export function wireControllerParams(_solutionType, _controllerDefinitions, _paramsObject) {
-    // TODO: KIT-4742: Implement
-    return {};
+import { ArrayValue, RecordValue, Schema, StringValue } from '@coveo/bueno';
+import { contextDefinition } from '../../../features/commerce/context/context-validation.js';
+import { parametersDefinition } from '../../../features/commerce/parameters/parameters-schema.js';
+import { nonEmptyString, requiredEmptyAllowedString, } from '../../../utils/validate-payload.js';
+import { SolutionType } from '../types/controller-constants.js';
+import { getRecommendationDefinitions, isRecommendationDefinition, } from './recommendation-filter.js';
+const requiredDefinition = {
+    context: new RecordValue({
+        options: { required: true },
+        values: contextDefinition,
+    }),
+};
+const listingDefinition = {
+    ...requiredDefinition,
+    searchParams: new RecordValue({
+        values: parametersDefinition,
+    }),
+};
+const standaloneDefinition = {
+    ...requiredDefinition,
+};
+const searchDefinition = {
+    ...requiredDefinition,
+    searchParams: new RecordValue({
+        options: { required: true },
+        values: { query: requiredEmptyAllowedString, ...parametersDefinition },
+    }),
+};
+const recommendationsDefinition = (recommendationName) => ({
+    ...requiredDefinition,
+    recommendations: new ArrayValue({
+        each: new StringValue({
+            required: true,
+            constrainTo: recommendationName,
+            emptyAllowed: false,
+        }),
+        required: true,
+    }),
+    productId: nonEmptyString,
+});
+export const listingDefinitionSchema = new Schema(listingDefinition);
+export const searchDefinitionSchema = new Schema(searchDefinition);
+export const standaloneDefinitionSchema = new Schema(standaloneDefinition);
+export const recommendationsDefinitionSchema = (recommendationName) => new Schema(recommendationsDefinition(recommendationName));
+/**
+ * Validates the build configuration based on the solution type.
+ */
+function validateBuildConfig(solutionType, controllerDefinitions, buildConfig) {
+    const validationMap = {
+        [SolutionType.listing]: listingDefinitionSchema,
+        [SolutionType.search]: searchDefinitionSchema,
+        [SolutionType.standalone]: standaloneDefinitionSchema,
+        [SolutionType.recommendation]: recommendationsDefinitionSchema(Object.keys(getRecommendationDefinitions(controllerDefinitions))),
+    };
+    const schema = validationMap[solutionType];
+    schema.validate(buildConfig);
+}
+/**
+ * Controller wiring class that handles the complete wiring process.
+ * Transforms simple user configuration into complex internal controller structures.
+ */
+class ControllerWirer {
+    buildConfig;
+    controllerDefinitions;
+    controllerProps;
+    constructor(buildConfig, controllerDefinitions, controllerProps) {
+        this.buildConfig = buildConfig;
+        this.controllerDefinitions = controllerDefinitions;
+        this.controllerProps = controllerProps;
+    }
+    wireParameterManager() {
+        if (!this.controllerDefinitions?.parameterManager)
+            return;
+        const { searchParams } = this.buildConfig;
+        const { query, ...rest } = searchParams || {};
+        const parameters = {
+            ...(query && { q: query }),
+            ...(rest && typeof rest === 'object' ? rest : {}),
+        };
+        this.controllerProps.parameterManager = {
+            initialState: { parameters },
+        };
+    }
+    wireContext() {
+        if (!this.controllerDefinitions?.context)
+            return;
+        const { context } = this.buildConfig;
+        this.controllerProps.context = {
+            initialState: {
+                ...context,
+            },
+        };
+    }
+    wireCart() {
+        if (!this.controllerDefinitions?.cart || !this.buildConfig.cart)
+            return;
+        this.controllerProps.cart = {
+            initialState: this.buildConfig.cart,
+        };
+    }
+    wireRecommendations() {
+        if (!('recommendations' in this.buildConfig)) {
+            return;
+        }
+        for (const recController in this.controllerDefinitions) {
+            if (isRecommendationDefinition(this.controllerDefinitions[recController])) {
+                this.controllerProps[recController] = {
+                    initialState: {
+                        ...('productId' in this.buildConfig && {
+                            productId: this.buildConfig.productId,
+                        }),
+                    },
+                };
+            }
+        }
+    }
+    /**
+     * Wires all controllers based on solution type and controller definitions.
+     * Handles the complete wiring process in a sequential manner.
+     */
+    wire(solutionType) {
+        // Wire common controllers that apply to all solution types
+        this.wireCart();
+        this.wireContext();
+        // Wire solution-specific controllers
+        switch (solutionType) {
+            case SolutionType.search:
+            case SolutionType.listing: {
+                this.wireParameterManager();
+                break;
+            }
+            case SolutionType.recommendation: {
+                this.wireRecommendations();
+                break;
+            }
+            case SolutionType.standalone:
+                // No additional wiring needed for standalone
+                break;
+            default: {
+                // Exhaustive check - TypeScript will error if we miss a case
+                const _exhaustiveCheck = solutionType;
+                throw new Error(`Unsupported solution type: ${_exhaustiveCheck}`);
+            }
+        }
+    }
+}
+/**
+ * Converts simple user configuration (URL, language, currency, query) into the
+ * nested structure required by the internal {@link Build} method. Automatically generates
+ * appropriate controllers (context, cart, parameterManager) transparently.
+ *
+ * @param solutionType - The type of solution (search, listing, recommendation, standalone)
+ * @param controllerDefinitions - Map of controller definitions to be initialized
+ * @param buildConfig - Simple configuration object with simplified controller properties
+ * @returns Formatted and validated controller properties map defined for the controller in the definition
+ */
+export function wireControllerParams(solutionType, controllerDefinitions, buildConfig) {
+    validateBuildConfig(solutionType, controllerDefinitions, buildConfig);
+    const controllerProps = buildConfig.controllers ?? {};
+    new ControllerWirer(buildConfig, controllerDefinitions, controllerProps).wire(solutionType);
+    return controllerProps;
 }

package/dist/esm/ssr-next/commerce/utils/engine-wiring.js

@@ -1,4 +1,10 @@
-export function extendEngineConfiguration(_configuration, _commonBuildOptions) {
-    // TODO: KIT-4742: Implement: wire engine configuration with validation
-    return {};
+export function extendEngineConfiguration(configuration, commonBuildOptions) {
+    const { cart, context } = commonBuildOptions;
+    return {
+        ...configuration,
+        context: {
+            ...context,
+        },
+        cart,
+    };
 }

package/dist/esm/ssr-next/commerce/utils/recommendation-filter.js

@@ -1,15 +1,34 @@
 import { MultipleRecommendationError } from '../../common/errors.js';
 import { recommendationInternalOptionKey } from '../types/controller-constants.js';
+/**
+ * Type guard to check if a controller definition is a recommendation controller.
+ * A recommendation controller must have both the recommendation flag and a slotId.
+ */
+export function isRecommendationDefinition(controllerDefinition) {
+    const hasRecommendationFlag = 'recommendation' in controllerDefinition &&
+        controllerDefinition.recommendation === true;
+    const hasValidSlotId = recommendationInternalOptionKey in controllerDefinition &&
+        'slotId' in
+            controllerDefinition[recommendationInternalOptionKey];
+    return hasRecommendationFlag && hasValidSlotId;
+}
+/**
+ * Extracts recommendation controller definitions from a controller definitions map.
+ *
+ * @param controllerDefinitions - Map of controller definitions
+ * @returns Object containing only the recommendation controller definitions
+ */
+export function getRecommendationDefinitions(controllerDefinitions) {
+    const recommendationMap = {};
+    for (const [name, definition] of Object.entries(controllerDefinitions)) {
+        if (isRecommendationDefinition(definition)) {
+            recommendationMap[name] = definition;
+        }
+    }
+    return recommendationMap;
+}
 export function filterRecommendationControllers(controllers, controllerDefinitions) {
     const slotIdSet = new Set();
-    const isRecommendationDefinition = (controllerDefinition) => {
-        const isControllerRecommendation = 'recommendation' in controllerDefinition &&
-            controllerDefinition.recommendation === true;
-        const hasSlotId = recommendationInternalOptionKey in controllerDefinition &&
-            'slotId' in
-                controllerDefinition[recommendationInternalOptionKey];
-        return isControllerRecommendation && hasSlotId;
-    };
     const ensureSingleRecommendationPerSlot = (slotId) => {
         throw new MultipleRecommendationError(slotId);
     };

package/dist/esm/test/mock-ssr-controller-definitions.js

@@ -1,4 +1,5 @@
 import { vi } from 'vitest';
+import { recommendationInternalOptionKey } from '../ssr-next/commerce/types/controller-constants.js';
 import { buildMockController, buildMockControllerWithInitialState, } from './mock-controller.js';
 export function defineMockController() {
     return {
@@ -41,3 +42,17 @@ export function defineMockCommerceControllerWithProps(options) {
         recommendation: options?.recommendation ?? true,
     };
 }
+export function defineMockRecommendationDefinition(slotId) {
+    return {
+        recommendation: true,
+        [recommendationInternalOptionKey]: {
+            slotId,
+        },
+        buildWithProps: vi.fn((engine, props) => ({
+            _kind: 'some-kind',
+            ...buildMockControllerWithInitialState(engine, {
+                initialState: props?.initialState,
+            }),
+        })),
+    };
+}

package/dist/esm/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "3.29.1" || 'Test version';
+export const VERSION = "3.29.2-pre.027eeece31" || 'Test version';
 export const COVEO_FRAMEWORK = ['@coveo/atomic', '@coveo/quantic'];