@n8n/workflow-sdk 0.35.2 → 0.36.0

package/dist/generate-types/generate-types.d.ts

@@ -149,10 +149,12 @@ export declare function tryMergeUxForkVariants(a: NodeProperty['displayOptions']
 export declare function mapPropertyType(prop: NodeProperty, discriminatorContext?: DiscriminatorCombination): string;
 export declare function extractDiscriminatorCombinations(node: NodeTypeDescription): DiscriminatorCombination[];
 export declare function getPropertiesForCombination(node: NodeTypeDescription, combination: DiscriminatorCombination): NodeProperty[];
-export declare function propertyAppliesToVersion(prop: NodeProperty, version: number): boolean;
+export declare function propertyAppliesToVersion(prop: Pick<NodeProperty, 'displayOptions'>, version: number): boolean;
 export declare function filterPropertiesForVersion(properties: NodeProperty[], version: number): NodeProperty[];
 export declare function generateDiscriminatedUnion(node: NodeTypeDescription): string;
-export declare function generatePropertyJSDoc(prop: NodeProperty, discriminatorContext?: DiscriminatorCombination): string;
+export declare function generatePropertyJSDoc(prop: NodeProperty, discriminatorContext?: DiscriminatorCombination, options?: {
+    conditionallyRequired?: boolean;
+}): string;
 export declare function generateNodeJSDoc(node: NodeTypeDescription): string;
 export declare function generatePropertyLine(prop: NodeProperty, optional: boolean, discriminatorContext?: DiscriminatorCombination): string;
 export declare function groupVersionsByProperties(nodes: NodeTypeDescription[]): VersionGroup[];

package/dist/generate-types/generate-types.js

@@ -256,6 +256,9 @@ const AI_TYPE_TO_SUBNODE_FIELD = {
         canBeMultiple: false,
     },
 };
+function isNodeProperty(option) {
+    return typeof option.type === 'string' && typeof option.displayName === 'string';
+}
 function variationApplies(variation, combo) {
     const opts = variation.displayOptions;
     if (!combo)
@@ -814,7 +817,7 @@ function quotePropertyName(name) {
     }
     return name;
 }
-function generateNestedPropertyJSDoc(prop, indent, discriminatorContext) {
+function generateNestedPropertyJSDoc(prop, indent, discriminatorContext, displayOptionsVariants) {
     const lines = [];
     const description = prop.description ?? prop.displayName;
     if (description) {
@@ -848,45 +851,9 @@ function generateNestedPropertyJSDoc(prop, indent, discriminatorContext) {
     if (typeof prop.typeOptions?.loadOptionsMethod === 'string') {
         lines.push(`${indent} * @loadOptionsMethod ${prop.typeOptions.loadOptionsMethod}`);
     }
-    if (prop.displayOptions) {
-        if (prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) {
-            const filteredShow = Object.entries(prop.displayOptions.show).filter(([key, values]) => {
-                if (key === '@version')
-                    return false;
-                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
-                if (discriminatorContext?.[normalizedKey] !== undefined) {
-                    const showValues = values;
-                    if (showValues.includes(discriminatorContext[normalizedKey]))
-                        return false;
-                }
-                return true;
-            });
-            if (filteredShow.length > 0) {
-                const showConditions = filteredShow
-                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
-                    .join(', ');
-                lines.push(`${indent} * @displayOptions.show { ${showConditions} }`);
-            }
-        }
-        if (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0) {
-            const filteredHide = Object.entries(prop.displayOptions.hide).filter(([key, values]) => {
-                if (key === '@version')
-                    return false;
-                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
-                if (discriminatorContext?.[normalizedKey] !== undefined) {
-                    const hideValues = values;
-                    if (hideValues.includes(discriminatorContext[normalizedKey]))
-                        return false;
-                }
-                return true;
-            });
-            if (filteredHide.length > 0) {
-                const hideConditions = filteredHide
-                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
-                    .join(', ');
-                lines.push(`${indent} * @displayOptions.hide { ${hideConditions} }`);
-            }
-        }
+    const variants = displayOptionsVariants ?? [prop.displayOptions];
+    for (const displayOptions of mergeDisplayOptionsVariants(variants, discriminatorContext)) {
+        lines.push(...formatDisplayOptionsJSDocLines(displayOptions, indent, discriminatorContext));
     }
     if (prop.default !== undefined && prop.default !== null && prop.default !== '') {
         let defaultStr;
@@ -903,6 +870,136 @@ function generateNestedPropertyJSDoc(prop, indent, discriminatorContext) {
     lines.push(`${indent} */`);
     return lines.join('\n');
 }
+function getResidualDisplayOptions(displayOptions, discriminatorContext) {
+    const residual = {};
+    if (!displayOptions)
+        return residual;
+    const keep = ([key]) => {
+        if (key === '@version')
+            return false;
+        const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
+        return discriminatorContext?.[normalizedKey] === undefined;
+    };
+    const show = Object.entries(displayOptions.show ?? {}).filter(keep);
+    if (show.length > 0)
+        residual.show = Object.fromEntries(show);
+    const hide = Object.entries(displayOptions.hide ?? {}).filter(keep);
+    if (hide.length > 0)
+        residual.hide = Object.fromEntries(hide);
+    return residual;
+}
+function hasResidualDisplayOptions(displayOptions, discriminatorContext) {
+    const residual = getResidualDisplayOptions(displayOptions, discriminatorContext);
+    return residual.show !== undefined || residual.hide !== undefined;
+}
+function formatDisplayOptionsJSDocLines(displayOptions, indent, discriminatorContext) {
+    const residual = getResidualDisplayOptions(displayOptions, discriminatorContext);
+    const format = (conditions) => Object.entries(conditions)
+        .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
+        .join(', ');
+    const lines = [];
+    if (residual.show)
+        lines.push(`${indent} * @displayOptions.show { ${format(residual.show)} }`);
+    if (residual.hide)
+        lines.push(`${indent} * @displayOptions.hide { ${format(residual.hide)} }`);
+    return lines;
+}
+function mergeDisplayOptionsVariants(variants, discriminatorContext) {
+    const residuals = new Map();
+    for (const variant of variants) {
+        const residual = getResidualDisplayOptions(variant, discriminatorContext);
+        if (residual.show === undefined && residual.hide === undefined)
+            return [];
+        residuals.set(JSON.stringify(residual), residual);
+    }
+    const merged = [];
+    for (const residual of residuals.values()) {
+        const last = merged[merged.length - 1];
+        const combined = last
+            ? (tryMergeUxForkVariants(last, residual) ?? tryMergeShowValueVariants(last, residual))
+            : null;
+        if (combined) {
+            merged[merged.length - 1] = combined;
+        }
+        else {
+            merged.push(residual);
+        }
+    }
+    return merged;
+}
+function tryMergeShowValueVariants(a, b) {
+    if (a.hide !== undefined || b.hide !== undefined)
+        return null;
+    if (a.show === undefined || b.show === undefined)
+        return null;
+    const aShow = a.show;
+    const bShow = b.show;
+    const keys = Object.keys(aShow);
+    if (keys.length !== Object.keys(bShow).length || keys.some((key) => !(key in bShow))) {
+        return null;
+    }
+    const differing = keys.filter((key) => JSON.stringify(aShow[key]) !== JSON.stringify(bShow[key]));
+    if (differing.length !== 1)
+        return null;
+    const [key] = differing;
+    const seen = new Set(aShow[key].map((value) => JSON.stringify(value)));
+    const values = [...aShow[key], ...bShow[key].filter((v) => !seen.has(JSON.stringify(v)))];
+    return { show: { ...aShow, [key]: values } };
+}
+function appliesToCombination(displayOptions, combination) {
+    if (!displayOptions || !combination)
+        return true;
+    const valueFor = (key) => combination[key.startsWith('/') ? key.slice(1) : key];
+    for (const [key, conditions] of Object.entries(displayOptions.show ?? {})) {
+        const value = valueFor(key);
+        if (value !== undefined && !(0, display_options_1.checkConditions)(conditions, [value]))
+            return false;
+    }
+    for (const [key, conditions] of Object.entries(displayOptions.hide ?? {})) {
+        const value = valueFor(key);
+        if (value !== undefined && (0, display_options_1.checkConditions)(conditions, [value]))
+            return false;
+    }
+    return true;
+}
+function emitNestedPropertyLines(properties, indent, discriminatorContext) {
+    const variantsByName = new Map();
+    for (const prop of properties) {
+        if (DISPLAY_ONLY_PROPERTY_TYPES.has(prop.type))
+            continue;
+        if (!appliesToCombination(prop.displayOptions, discriminatorContext))
+            continue;
+        const type = mapNestedPropertyType(prop, discriminatorContext);
+        if (!type)
+            continue;
+        const variants = variantsByName.get(prop.name) ?? [];
+        variants.push({ prop, type });
+        variantsByName.set(prop.name, variants);
+    }
+    const lines = [];
+    for (const [name, variants] of variantsByName) {
+        const quotedName = quotePropertyName(name);
+        const variantsByType = new Map();
+        for (const { prop, type } of variants) {
+            const props = variantsByType.get(type) ?? [];
+            props.push(prop);
+            variantsByType.set(type, props);
+        }
+        if (variantsByType.size === 1) {
+            const [type, props] = Array.from(variantsByType.entries())[0];
+            const jsDoc = generateNestedPropertyJSDoc(props[0], indent, discriminatorContext, props.map((p) => p.displayOptions));
+            lines.push(`${jsDoc}\n${indent}${quotedName}?: ${type}`);
+            continue;
+        }
+        const memberIndent = indent + INDENT;
+        const members = Array.from(variantsByType.entries()).map(([type, props]) => {
+            const jsDoc = generateNestedPropertyJSDoc(props[0], memberIndent, discriminatorContext, props.map((p) => p.displayOptions));
+            return `${jsDoc}\n${memberIndent}| ${type}`;
+        });
+        lines.push(`${indent}${quotedName}?:\n${members.join('\n')}`);
+    }
+    return lines;
+}
 function generateFixedCollectionType(prop, discriminatorContext) {
     if (!prop.options || prop.options.length === 0) {
         return 'Record<string, unknown>';
@@ -914,18 +1011,7 @@ function generateFixedCollectionType(prop, discriminatorContext) {
             continue;
         }
         const groupName = quotePropertyName(group.name);
-        const nestedProps = [];
-        for (const nestedProp of group.values) {
-            if (DISPLAY_ONLY_PROPERTY_TYPES.has(nestedProp.type)) {
-                continue;
-            }
-            const nestedType = mapNestedPropertyType(nestedProp, discriminatorContext);
-            if (nestedType) {
-                const quotedName = quotePropertyName(nestedProp.name);
-                const jsDoc = generateNestedPropertyJSDoc(nestedProp, INDENT.repeat(3), discriminatorContext);
-                nestedProps.push(`${jsDoc}\n${INDENT.repeat(3)}${quotedName}?: ${nestedType}`);
-            }
-        }
+        const nestedProps = emitNestedPropertyLines(group.values, INDENT.repeat(3), discriminatorContext);
         if (nestedProps.length > 0) {
             const innerType = `{\n${nestedProps.join(';\n')};\n${INDENT.repeat(2)}}`;
             const minRequired = prop.typeOptions?.minRequiredFields;
@@ -1139,22 +1225,10 @@ function generateCollectionType(prop, discriminatorContext) {
     if (!prop.options || prop.options.length === 0) {
         return 'Record<string, unknown>';
     }
-    const nestedProps = [];
-    for (const nestedProp of prop.options) {
-        if (nestedProp.values !== undefined) {
-            continue;
-        }
-        const nestedType = nestedProp.type;
-        if (DISPLAY_ONLY_PROPERTY_TYPES.has(nestedType)) {
-            continue;
-        }
-        const propType = mapNestedPropertyType(nestedProp, discriminatorContext);
-        if (propType) {
-            const quotedName = quotePropertyName(nestedProp.name);
-            const jsDoc = generateNestedPropertyJSDoc(nestedProp, INDENT.repeat(2), discriminatorContext);
-            nestedProps.push(`${jsDoc}\n${INDENT.repeat(2)}${quotedName}?: ${propType}`);
-        }
-    }
+    const nestedProperties = prop.options
+        .filter((option) => option.values === undefined)
+        .filter(isNodeProperty);
+    const nestedProps = emitNestedPropertyLines(nestedProperties, INDENT.repeat(2), discriminatorContext);
     if (nestedProps.length === 0) {
         return 'Record<string, unknown>';
     }
@@ -1413,8 +1487,33 @@ function propertyAppliesToVersion(prop, version) {
     }
     return true;
 }
+function filterNestedOptionsForVersion(prop, version) {
+    if (!prop.options)
+        return prop;
+    let changed = false;
+    const options = [];
+    for (const option of prop.options) {
+        if (!propertyAppliesToVersion(option, version)) {
+            changed = true;
+            continue;
+        }
+        let next = filterNestedOptionsForVersion(option, version);
+        if (next.values) {
+            const values = filterPropertiesForVersion(next.values, version);
+            if (values.length !== next.values.length || values.some((v, i) => v !== next.values?.[i])) {
+                next = { ...next, values };
+            }
+        }
+        if (next !== option)
+            changed = true;
+        options.push(next);
+    }
+    return changed ? { ...prop, options } : prop;
+}
 function filterPropertiesForVersion(properties, version) {
-    return properties.filter((prop) => propertyAppliesToVersion(prop, version));
+    return properties
+        .filter((prop) => propertyAppliesToVersion(prop, version))
+        .map((prop) => filterNestedOptionsForVersion(prop, version));
 }
 function generateDiscriminatedUnion(node) {
     const combinations = extractDiscriminatorCombinations(node);
@@ -1477,7 +1576,7 @@ function generateDiscriminatedUnion(node) {
     }
     return lines.join('\n');
 }
-function generatePropertyJSDoc(prop, discriminatorContext) {
+function generatePropertyJSDoc(prop, discriminatorContext, options) {
     const lines = ['/**'];
     const description = prop.description ?? prop.displayName;
     const safeDescription = description
@@ -1506,45 +1605,9 @@ function generatePropertyJSDoc(prop, discriminatorContext) {
     if (typeof prop.typeOptions?.loadOptionsMethod === 'string') {
         lines.push(` * @loadOptionsMethod ${prop.typeOptions.loadOptionsMethod}`);
     }
-    if (prop.displayOptions) {
-        if (prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) {
-            const filteredShow = Object.entries(prop.displayOptions.show).filter(([key, values]) => {
-                if (key === '@version')
-                    return false;
-                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
-                if (discriminatorContext?.[normalizedKey] !== undefined) {
-                    const showValues = values;
-                    if (showValues.includes(discriminatorContext[normalizedKey]))
-                        return false;
-                }
-                return true;
-            });
-            if (filteredShow.length > 0) {
-                const showConditions = filteredShow
-                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
-                    .join(', ');
-                lines.push(` * @displayOptions.show { ${showConditions} }`);
-            }
-        }
-        if (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0) {
-            const filteredHide = Object.entries(prop.displayOptions.hide).filter(([key, values]) => {
-                if (key === '@version')
-                    return false;
-                const normalizedKey = key.startsWith('/') ? key.slice(1) : key;
-                if (discriminatorContext?.[normalizedKey] !== undefined) {
-                    const hideValues = values;
-                    if (hideValues.includes(discriminatorContext[normalizedKey]))
-                        return false;
-                }
-                return true;
-            });
-            if (filteredHide.length > 0) {
-                const hideConditions = filteredHide
-                    .map(([key, values]) => `${key}: [${values.map((v) => JSON.stringify(v)).join(', ')}]`)
-                    .join(', ');
-                lines.push(` * @displayOptions.hide { ${hideConditions} }`);
-            }
-        }
+    lines.push(...formatDisplayOptionsJSDocLines(prop.displayOptions, '', discriminatorContext));
+    if (options?.conditionallyRequired) {
+        lines.push(' * @required when the displayOptions conditions above match');
     }
     if (prop.default !== undefined && prop.default !== null && prop.default !== '') {
         let defaultStr;
@@ -1598,18 +1661,19 @@ function generatePropertyLine(prop, optional, discriminatorContext) {
         return '';
     }
     const lines = [];
+    const conditionallyRequired = !optional && hasResidualDisplayOptions(prop.displayOptions, discriminatorContext);
     const hasDisplayOptions = prop.displayOptions &&
         ((prop.displayOptions.show && Object.keys(prop.displayOptions.show).length > 0) ||
             (prop.displayOptions.hide && Object.keys(prop.displayOptions.hide).length > 0));
     if (prop.description || hasDisplayOptions || prop.hint || prop.builderHint) {
-        lines.push(generatePropertyJSDoc(prop, discriminatorContext));
+        lines.push(generatePropertyJSDoc(prop, discriminatorContext, { conditionallyRequired }));
     }
     let propName = prop.name;
     const needsQuoting = RESERVED_WORDS.has(propName) || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName);
     if (needsQuoting) {
         propName = `'${propName.replace(/'/g, "\\'")}'`;
     }
-    const optionalMarker = optional ? '?' : '';
+    const optionalMarker = optional || conditionallyRequired ? '?' : '';
     lines.push(`${INDENT}${propName}${optionalMarker}: ${tsType};`);
     return lines.join(`\n${INDENT}`);
 }