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

package/dist/index.d.ts

@@ -424,12 +424,16 @@ type Parameter = z.infer<typeof ParameterSchema>;
 declare const VariableMappingSchema: z.ZodObject<{
     parameterId: z.ZodString;
     type: z.ZodLiteral<"ContentTypeMapping">;
-    pathsByContentType: z.ZodRecord<z.ZodString, z.ZodObject<{
+    pathsByContentType: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
         path: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         path: string;
     }, {
         path: string;
+    }>>, Record<string, {
+        path: string;
+    }>, Record<string, {
+        path: string;
     }>>;
 }, "strip", z.ZodTypeAny, {
     type: "ContentTypeMapping";
@@ -547,7 +551,7 @@ declare const ParameterDefinitionSchema: z.ZodObject<{
         nodeId: string;
     }[] | undefined;
 }>;
-declare const ComponentSettingsSchema: z.ZodObject<{
+declare const ComponentSettingsSchema: z.ZodEffects<z.ZodObject<{
     variableDefinitions: z.ZodRecord<z.ZodString, z.ZodObject<{
         displayName: z.ZodOptional<z.ZodString>;
         type: z.ZodEnum<["Text", "RichText", "Number", "Date", "Boolean", "Location", "Media", "Object", "Hyperlink", "Array", "Link"]>;
@@ -816,12 +820,16 @@ declare const ComponentSettingsSchema: z.ZodObject<{
         variableMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             parameterId: z.ZodString;
             type: z.ZodLiteral<"ContentTypeMapping">;
-            pathsByContentType: z.ZodRecord<z.ZodString, z.ZodObject<{
+            pathsByContentType: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
                 path: z.ZodString;
             }, "strip", z.ZodTypeAny, {
                 path: string;
             }, {
                 path: string;
+            }>>, Record<string, {
+                path: string;
+            }>, Record<string, {
+                path: string;
             }>>;
         }, "strip", z.ZodTypeAny, {
             type: "ContentTypeMapping";
@@ -1030,8 +1038,142 @@ declare const ComponentSettingsSchema: z.ZodObject<{
         }> | undefined;
         allowedVariableOverrides?: string[] | undefined;
     }[] | undefined;
+}>, {
+    variableDefinitions: Record<string, {
+        type: "Text" | "RichText" | "Number" | "Date" | "Boolean" | "Location" | "Media" | "Object" | "Hyperlink" | "Array" | "Link";
+        displayName?: string | undefined;
+        description?: string | undefined;
+        group?: string | undefined;
+        defaultValue?: string | number | boolean | Record<any, any> | {
+            type: "DesignValue";
+            valuesByBreakpoint: Record<string, string | number | boolean | Record<any, any> | undefined>;
+        } | {
+            path: string;
+            type: "BoundValue";
+        } | {
+            type: "HyperlinkValue";
+            linkTargetKey: string;
+            overrides?: {} | undefined;
+        } | {
+            type: "UnboundValue";
+            key: string;
+        } | {
+            type: "ComponentValue";
+            key: string;
+        } | {
+            type: "NoValue";
+        } | undefined;
+        validations?: {
+            required?: boolean | undefined;
+            bindingSourceType?: ["entry" | "asset" | "manual" | "experience", ...("entry" | "asset" | "manual" | "experience")[]] | undefined;
+            format?: "URL" | undefined;
+            in?: {
+                value: string | number;
+                displayName?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+    }>;
+    thumbnailId?: "columns" | "columnsPlusRight" | "imagesSquare" | "subtitles" | "rowsPlusBottom" | "userRectangle" | "textbox" | "monitorPlay" | "article" | "table" | "star" | "heartStraight" | "frameCorners" | "rows" | "dotsThreeOutline" | "listDashes" | "checkerBoard" | "gridFour" | "slideshow" | "diamondsFour" | "cards" | "textColumns" | "duplex" | undefined;
+    category?: string | undefined;
+    prebindingDefinitions?: {
+        id: string;
+        parameterDefinitions: Record<string, {
+            contentTypes: string[];
+            defaultSource?: {
+                type: "Entry";
+                contentTypeId: string;
+                link: {
+                    sys: {
+                        type: "Link";
+                        id: string;
+                        linkType: "Entry";
+                    };
+                };
+            } | undefined;
+            passToNodes?: {
+                prebindingId: string;
+                parameterId: string;
+                nodeId: string;
+            }[] | undefined;
+        }>;
+        variableMappings?: Record<string, {
+            type: "ContentTypeMapping";
+            parameterId: string;
+            pathsByContentType: Record<string, {
+                path: string;
+            }>;
+        }> | undefined;
+        allowedVariableOverrides?: string[] | undefined;
+    }[] | undefined;
+}, {
+    variableDefinitions: Record<string, {
+        type: "Text" | "RichText" | "Number" | "Date" | "Boolean" | "Location" | "Media" | "Object" | "Hyperlink" | "Array" | "Link";
+        displayName?: string | undefined;
+        description?: string | undefined;
+        group?: string | undefined;
+        defaultValue?: string | number | boolean | Record<any, any> | {
+            type: "DesignValue";
+            valuesByBreakpoint: Record<string, string | number | boolean | Record<any, any> | undefined>;
+        } | {
+            path: string;
+            type: "BoundValue";
+        } | {
+            type: "HyperlinkValue";
+            linkTargetKey: string;
+            overrides?: {} | undefined;
+        } | {
+            type: "UnboundValue";
+            key: string;
+        } | {
+            type: "ComponentValue";
+            key: string;
+        } | {
+            type: "NoValue";
+        } | undefined;
+        validations?: {
+            required?: boolean | undefined;
+            bindingSourceType?: ["entry" | "asset" | "manual" | "experience", ...("entry" | "asset" | "manual" | "experience")[]] | undefined;
+            format?: "URL" | undefined;
+            in?: {
+                value: string | number;
+                displayName?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+    }>;
+    thumbnailId?: "columns" | "columnsPlusRight" | "imagesSquare" | "subtitles" | "rowsPlusBottom" | "userRectangle" | "textbox" | "monitorPlay" | "article" | "table" | "star" | "heartStraight" | "frameCorners" | "rows" | "dotsThreeOutline" | "listDashes" | "checkerBoard" | "gridFour" | "slideshow" | "diamondsFour" | "cards" | "textColumns" | "duplex" | undefined;
+    category?: string | undefined;
+    prebindingDefinitions?: {
+        id: string;
+        parameterDefinitions: Record<string, {
+            contentTypes: string[];
+            defaultSource?: {
+                type: "Entry";
+                contentTypeId: string;
+                link: {
+                    sys: {
+                        type: "Link";
+                        id: string;
+                        linkType: "Entry";
+                    };
+                };
+            } | undefined;
+            passToNodes?: {
+                prebindingId: string;
+                parameterId: string;
+                nodeId: string;
+            }[] | undefined;
+        }>;
+        variableMappings?: Record<string, {
+            type: "ContentTypeMapping";
+            parameterId: string;
+            pathsByContentType: Record<string, {
+                path: string;
+            }>;
+        }> | undefined;
+        allowedVariableOverrides?: string[] | undefined;
+    }[] | undefined;
 }>;
-declare const PatternFieldsCMAShapeSchema: z.ZodObject<{
+declare const PatternFieldsCMAShapeSchema: z.ZodEffects<z.ZodObject<{
     componentTree: z.ZodRecord<z.ZodString, z.ZodTypeAny>;
     dataSource: z.ZodRecord<z.ZodString, z.ZodTypeAny>;
     unboundValues: z.ZodRecord<z.ZodString, z.ZodTypeAny>;
@@ -1049,6 +1191,18 @@ declare const PatternFieldsCMAShapeSchema: z.ZodObject<{
     unboundValues: Record<string, any>;
     componentSettings: Record<string, any>;
     usedComponents?: Record<string, any> | undefined;
+}>, {
+    componentTree: Record<string, any>;
+    dataSource: Record<string, any>;
+    unboundValues: Record<string, any>;
+    componentSettings: Record<string, any>;
+    usedComponents?: Record<string, any> | undefined;
+}, {
+    componentTree: Record<string, any>;
+    dataSource: Record<string, any>;
+    unboundValues: Record<string, any>;
+    componentSettings: Record<string, any>;
+    usedComponents?: Record<string, any> | undefined;
 }>;
 type PatternFields = z.infer<typeof PatternFieldsCMAShapeSchema>;
 type ParameterDefinition = z.infer<typeof ParameterDefinitionSchema>;

package/dist/index.js

@@ -247,6 +247,25 @@ const ExperienceFieldsCMAShapeSchema = z.object({
     usedComponents: localeWrapper(UsedComponentsSchema).optional(),
 });
 
+function treeVisit(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',
@@ -277,7 +296,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({
@@ -301,7 +330,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);
@@ -322,14 +354,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();
-const PatternFieldsCMAShapeSchema = 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);
+});
+const PatternFieldsCMAShapeSchema = 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(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}.`,
+        });
+    }
+};
 
 const ComponentDefinitionSchema = z
     .object({