@contentful/experiences-core 3.7.0-dev-20250917T1203-0e23897.0 → 3.7.0-dev-20250917T1515-4c340b9.0

package/dist/index.js

@@ -1052,6 +1052,25 @@ z.object({
     usedComponents: localeWrapper(UsedComponentsSchema).optional(),
 });
 
+function treeVisit$1(initialNode, onNode) {
+    const _treeVisit = (currentNode) => {
+        const children = [...currentNode.children];
+        onNode(currentNode);
+        for (const child of children) {
+            _treeVisit(child);
+        }
+    };
+    if (Array.isArray(initialNode)) {
+        for (const node of initialNode) {
+            _treeVisit(node);
+        }
+    }
+    else {
+        _treeVisit(initialNode);
+    }
+}
+
+const MAX_ALLOWED_PATHS = 200;
 const THUMBNAIL_IDS = [
     'columns',
     'columnsPlusRight',
@@ -1082,7 +1101,17 @@ const THUMBNAIL_IDS = [
 const VariableMappingSchema = z.object({
     parameterId: propertyKeySchema,
     type: z.literal('ContentTypeMapping'),
-    pathsByContentType: z.record(z.string(), z.object({ path: z.string() })),
+    pathsByContentType: z
+        .record(z.string(), z.object({ path: z.string() }))
+        .superRefine((paths, ctx) => {
+        const variableId = ctx.path[ctx.path.length - 2];
+        if (Object.keys(paths).length > MAX_ALLOWED_PATHS) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Too many paths defined for variable mapping with id "${variableId}", maximum allowed is ${MAX_ALLOWED_PATHS}`,
+            });
+        }
+    }),
 });
 const PassToNodeSchema = z
     .object({
@@ -1106,7 +1135,10 @@ const ParameterDefinitionSchema = z.object({
     })
         .optional(),
     contentTypes: z.array(z.string()).min(1),
-    passToNodes: z.array(PassToNodeSchema).optional(),
+    passToNodes: z
+        .array(PassToNodeSchema)
+        .max(1, 'At most one "passToNodes" element is allowed per parameter definition.')
+        .optional(), // we might change this to be empty array for native parameter definitions, that's why we don't use .length(1)
 });
 const ParameterDefinitionsSchema = z.record(propertyKeySchema, ParameterDefinitionSchema);
 const VariableMappingsSchema = z.record(propertyKeySchema, VariableMappingSchema);
@@ -1127,14 +1159,108 @@ const ComponentSettingsSchema = z
     category: z.string().max(50, 'Category must contain at most 50 characters').optional(),
     prebindingDefinitions: z.array(PrebindingDefinitionSchema).length(1).optional(),
 })
-    .strict();
-z.object({
+    .strict()
+    .superRefine((componentSettings, ctx) => {
+    const { variableDefinitions, prebindingDefinitions } = componentSettings;
+    if (!prebindingDefinitions || prebindingDefinitions.length === 0) {
+        return;
+    }
+    const { parameterDefinitions, variableMappings, allowedVariableOverrides } = prebindingDefinitions[0];
+    validateAtMostOneNativeParameterDefinition(parameterDefinitions, ctx);
+    validateNoOverlapBetweenMappingAndOverrides(variableMappings, allowedVariableOverrides, ctx);
+    validateMappingsAgainstVariableDefinitions(variableMappings, allowedVariableOverrides, variableDefinitions, ctx);
+    validateMappingsAgainstParameterDefinitions(variableMappings, parameterDefinitions, ctx);
+});
+z
+    .object({
     componentTree: localeWrapper(ComponentTreeSchema),
     dataSource: localeWrapper(DataSourceSchema),
     unboundValues: localeWrapper(UnboundValuesSchema),
     usedComponents: localeWrapper(UsedComponentsSchema).optional(),
     componentSettings: localeWrapper(ComponentSettingsSchema),
+})
+    .superRefine((patternFields, ctx) => {
+    const { componentTree, componentSettings } = patternFields;
+    // values at this point are wrapped under locale code
+    const nonLocalisedComponentTree = Object.values(componentTree)[0];
+    const nonLocalisedComponentSettings = Object.values(componentSettings)[0];
+    if (!nonLocalisedComponentSettings || !nonLocalisedComponentTree) {
+        return;
+    }
+    validatePassToNodes(nonLocalisedComponentTree.children || [], nonLocalisedComponentSettings || {}, ctx);
 });
+const validateAtMostOneNativeParameterDefinition = (parameterDefinitions, ctx) => {
+    const nativeParamDefinitions = Object.values(parameterDefinitions).filter((paramDefinition) => !(paramDefinition.passToNodes && paramDefinition.passToNodes.length > 0));
+    if (nativeParamDefinitions.length > 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Only one native parameter definition (parameter definition without passToNodes) is allowed per prebinding definition.`,
+        });
+    }
+};
+const validateNoOverlapBetweenMappingAndOverrides = (variableMappings, allowedVariableOverrides, ctx) => {
+    const variableMappingKeys = Object.keys(variableMappings || {});
+    const overridesSet = new Set(allowedVariableOverrides || []);
+    const overlap = variableMappingKeys.filter((key) => overridesSet.has(key));
+    if (overlap.length > 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Found both variable mapping and allowed override for the following keys: ${overlap.map((key) => `"${key}"`).join(', ')}.`,
+        });
+    }
+};
+const validateMappingsAgainstVariableDefinitions = (variableMappings, allowedVariableOverrides, variableDefinitions, ctx) => {
+    const nonDesignVariableDefinitionKeys = Object.entries(variableDefinitions)
+        .filter(([_, def]) => def.group !== 'style')
+        .map(([key]) => key);
+    const variableMappingKeys = Object.keys(variableMappings || {});
+    const allKeys = [...variableMappingKeys, ...(allowedVariableOverrides || [])];
+    const invalidMappings = allKeys.filter((key) => !nonDesignVariableDefinitionKeys.includes(key));
+    if (invalidMappings.length > 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The following variable mappings or overrides are missing from the variable definitions: ${invalidMappings.map((key) => `"${key}"`).join(', ')}.`,
+        });
+    }
+};
+const validateMappingsAgainstParameterDefinitions = (variableMappings, parameterDefinitions, ctx) => {
+    const parameterDefinitionKeys = Object.keys(parameterDefinitions || {});
+    for (const [mappingKey, mappingValue] of Object.entries(variableMappings || {})) {
+        if (!parameterDefinitionKeys.includes(mappingValue.parameterId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `The variable mapping with id "${mappingKey}" references a non-existing parameterId "${mappingValue.parameterId}".`,
+            });
+        }
+    }
+};
+const validatePassToNodes = (rootChildren, componentSettings, ctx) => {
+    if (!componentSettings.prebindingDefinitions ||
+        componentSettings.prebindingDefinitions.length === 0) {
+        return;
+    }
+    const { parameterDefinitions } = componentSettings.prebindingDefinitions[0];
+    let nodeIds = new Set();
+    for (const paramDef of Object.values(parameterDefinitions || {})) {
+        paramDef.passToNodes?.forEach((n) => nodeIds.add(n.nodeId));
+    }
+    treeVisit$1(rootChildren, (node) => {
+        if (!node.id)
+            return;
+        if (nodeIds.has(node.id)) {
+            nodeIds.delete(node.id);
+        }
+    });
+    if (nodeIds.size > 0) {
+        const stringifiedNodeIds = Array.from(nodeIds)
+            .map((id) => `"${id}"`)
+            .join(', ');
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The following node IDs referenced in passToNodes are not present in the component tree: ${stringifiedNodeIds}.`,
+        });
+    }
+};
 
 z
     .object({