@n8n/workflow-sdk 0.37.1 → 0.38.0

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

@@ -108,6 +108,7 @@ export interface VersionGroup {
 export interface OutputSchema {
     resource: string;
     operation: string;
+    variant?: string;
     schema: JsonSchema;
 }
 export interface JsonSchema {
@@ -131,6 +132,7 @@ export declare function padVersion(version: number): string;
 export declare function computeSchemaCorpusHash(baseDirs?: string[]): string;
 export declare function jsonSchemaToTypeScript(schema: JsonSchema, indent?: number): string;
 export declare function findSchemaForOperation(schemas: OutputSchema[], resource: string, operation: string): OutputSchema | undefined;
+export declare function findVariantSchemasForOperation(schemas: OutputSchema[], resource: string, operation: string): OutputSchema[];
 export interface ConfigTypeInfo {
     typeName: string;
     resource?: string;
@@ -172,7 +174,7 @@ export interface DiscriminatorTree {
 }
 export declare function buildDiscriminatorTree(combinations: DiscriminatorCombination[]): DiscriminatorTree;
 export declare function generateSharedFile(node: NodeTypeDescription, version: number, _importDepth?: number): string;
-export declare function generateDiscriminatorFile(node: NodeTypeDescription, version: number, combo: DiscriminatorCombination, props: NodeProperty[], schema?: JsonSchema, _importDepth?: number): string;
+export declare function generateDiscriminatorFile(node: NodeTypeDescription, version: number, combo: DiscriminatorCombination, props: NodeProperty[], schema?: JsonSchema, _importDepth?: number, variantSchemas?: OutputSchema[]): string;
 export declare function generateResourceIndexFile(node: NodeTypeDescription, version: number, resource: string, operations: string[]): string;
 export declare function generateSplitVersionIndexFile(node: NodeTypeDescription, version: number, tree: DiscriminatorTree): string;
 export declare function planSplitVersionFiles(node: NodeTypeDescription, version: number): Map<string, string>;

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

@@ -43,6 +43,7 @@ exports.padVersion = padVersion;
 exports.computeSchemaCorpusHash = computeSchemaCorpusHash;
 exports.jsonSchemaToTypeScript = jsonSchemaToTypeScript;
 exports.findSchemaForOperation = findSchemaForOperation;
+exports.findVariantSchemasForOperation = findVariantSchemasForOperation;
 exports.narrowDisplayOptionsByDisabled = narrowDisplayOptionsByDisabled;
 exports.tryMergeUxForkVariants = tryMergeUxForkVariants;
 exports.mapPropertyType = mapPropertyType;
@@ -509,19 +510,21 @@ function collectSchemasFromVersionDir(versionDir, schemas, seen) {
             for (const opEntry of operations) {
                 if (!opEntry.isFile() || !opEntry.name.endsWith('.json'))
                     continue;
-                const operationName = opEntry.name.replace('.json', '');
-                if (seen.has(`${entry.name}/${operationName}`))
+                const fileKey = opEntry.name.replace('.json', '');
+                if (seen.has(`${entry.name}/${fileKey}`))
                     continue;
                 const schemaPath = path.join(resourceDir, opEntry.name);
+                const [operationName, variant] = splitOperationVariant(fileKey);
                 try {
                     const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
                     const schema = JSON.parse(schemaContent);
                     schemas.push({
                         resource: entry.name,
                         operation: operationName,
+                        ...(variant ? { variant } : {}),
                         schema,
                     });
-                    seen.add(`${entry.name}/${operationName}`);
+                    seen.add(`${entry.name}/${fileKey}`);
                 }
                 catch {
                 }
@@ -621,6 +624,10 @@ function orderedVersionDirectories(schemaDir, version) {
         return [];
     }
 }
+function indexSignatureType(additionalType, declaredTypes, hasOptional) {
+    const members = [additionalType, ...declaredTypes, ...(hasOptional ? ['undefined'] : [])];
+    return [...new Set(members)].join(' | ');
+}
 function jsonSchemaToTypeScript(schema, indent = 0) {
     const indentStr = INDENT.repeat(indent);
     const nextIndent = INDENT.repeat(indent + 1);
@@ -675,12 +682,19 @@ function jsonSchemaToTypeScript(schema, indent = 0) {
         case 'object':
             if (schema.properties && Object.keys(schema.properties).length > 0) {
                 const required = new Set(schema.required ?? []);
+                const declaredTypes = [];
                 const props = Object.entries(schema.properties).map(([key, propSchema]) => {
                     const optional = required.has(key) ? '' : '?';
                     const quotedKey = needsQuoting(key) ? `'${key}'` : key;
                     const propType = jsonSchemaToTypeScript(propSchema, indent + 1);
+                    declaredTypes.push(propType);
                     return `${nextIndent}${quotedKey}${optional}: ${propType};`;
                 });
+                if (typeof schema.additionalProperties === 'object') {
+                    const additionalType = jsonSchemaToTypeScript(schema.additionalProperties, indent + 1);
+                    const hasOptional = Object.keys(schema.properties).some((key) => !required.has(key));
+                    props.push(`${nextIndent}[key: string]: ${indexSignatureType(additionalType, declaredTypes, hasOptional)};`);
+                }
                 return `{\n${props.join('\n')}\n${indentStr}}`;
             }
             if (schema.additionalProperties) {
@@ -695,7 +709,20 @@ function jsonSchemaToTypeScript(schema, indent = 0) {
     }
 }
 function findSchemaForOperation(schemas, resource, operation) {
-    return schemas.find((s) => s.resource.toLowerCase() === resource.toLowerCase() && s.operation === operation);
+    return schemas.find((s) => !s.variant &&
+        s.resource.toLowerCase() === resource.toLowerCase() &&
+        s.operation === operation);
+}
+function splitOperationVariant(fileKey) {
+    const dot = fileKey.indexOf('.');
+    if (dot <= 0)
+        return [fileKey, undefined];
+    return [fileKey.slice(0, dot), fileKey.slice(dot + 1)];
+}
+function findVariantSchemasForOperation(schemas, resource, operation) {
+    return schemas.filter((s) => s.variant !== undefined &&
+        s.resource.toLowerCase() === resource.toLowerCase() &&
+        s.operation === operation);
 }
 function generateResourceLocatorType(prop) {
     if (prop.modes && prop.modes.length > 0) {
@@ -1871,7 +1898,104 @@ function generateSharedFile(node, version, _importDepth = 5) {
     lines.push('}');
     return lines.join('\n');
 }
-function generateDiscriminatorFile(node, version, combo, props, schema, _importDepth = 5) {
+function parseParameterVariant(variant) {
+    const separator = variant.indexOf('-');
+    if (separator <= 0)
+        return undefined;
+    return { param: variant.slice(0, separator), value: variant.slice(separator + 1) };
+}
+function resolveParameterVariants(props, variantSchemas) {
+    const parsed = variantSchemas.map((s) => ({
+        ...parseParameterVariant(s.variant ?? ''),
+        schema: s.schema,
+    }));
+    const param = parsed[0]?.param;
+    if (!param || parsed.some((entry) => entry.param !== param || entry.value === undefined)) {
+        return undefined;
+    }
+    const property = props.find((p) => p.name === param);
+    const valueType = property ? getParameterValueType(property) : undefined;
+    if (!property || !valueType)
+        return undefined;
+    const defaultValue = String(property.default);
+    const others = parsed.map((entry) => ({ value: entry.value, schema: entry.schema }));
+    if (others.some((entry) => entry.value === defaultValue || !isTypeSafeValue(valueType, entry.value))) {
+        return undefined;
+    }
+    const suffixes = [defaultValue, ...others.map((entry) => entry.value)].map((value) => parameterValueSuffix(valueType, value));
+    if (new Set(suffixes).size !== suffixes.length)
+        return undefined;
+    return {
+        param,
+        valueType,
+        defaultValue,
+        others: others.sort((a, b) => a.value.localeCompare(b.value)),
+    };
+}
+function getParameterValueType(property) {
+    if (property.type === 'boolean') {
+        return typeof property.default === 'boolean' ? 'boolean' : undefined;
+    }
+    if (property.type !== 'options')
+        return undefined;
+    if (typeof property.default === 'number')
+        return 'number';
+    if (typeof property.default === 'boolean')
+        return 'boolean';
+    return typeof property.default === 'string' ? 'string' : undefined;
+}
+function parameterValueSuffix(valueType, value) {
+    if (valueType === 'number')
+        return value.replace('-', 'Minus').replace('.', 'Point');
+    return toPascalCase(value);
+}
+function isTypeSafeValue(valueType, value) {
+    if (valueType === 'boolean')
+        return value === 'true' || value === 'false';
+    if (valueType === 'number')
+        return Number.isFinite(Number(value)) && String(Number(value)) === value;
+    return /^[\w-]+$/.test(value);
+}
+function parameterValueLiteral(variants, value) {
+    return variants.valueType === 'string' ? `'${value}'` : value;
+}
+function generateParameterVariantTypes(variants, names, nodeBody) {
+    const { param, defaultValue, others } = variants;
+    const suffixOf = (value) => `${toPascalCase(param)}${parameterValueSuffix(variants.valueType, value)}`;
+    const outputOf = (value) => `${names.base}${suffixOf(value)}Output`;
+    const nodeOf = (value) => `${names.base}${suffixOf(value)}Node`;
+    const lines = [];
+    for (const { value, schema: variantSchema } of others) {
+        lines.push(`export type ${outputOf(value)} = ${jsonSchemaToTypeScript(variantSchema)};`, '');
+    }
+    const members = [
+        {
+            node: nodeOf(defaultValue),
+            constraint: `${param}?: ${parameterValueLiteral(variants, defaultValue)}`,
+            output: names.output,
+        },
+        ...others.map(({ value }) => ({
+            node: nodeOf(value),
+            constraint: `${param}: ${parameterValueLiteral(variants, value)}`,
+            output: outputOf(value),
+        })),
+    ];
+    const allOutputs = members.map((member) => member.output).join(' | ');
+    members.push({
+        node: `${names.base}${toPascalCase(param)}ExpressionNode`,
+        constraint: `${param}: Expression<${variants.valueType}>`,
+        output: allOutputs,
+    });
+    for (const member of members) {
+        lines.push(...nodeBody(member.node, `{ ${member.constraint} }`, member.output), '');
+    }
+    lines.push(`export type ${names.node} =`);
+    members.forEach((member, index) => {
+        lines.push(`${INDENT}| ${member.node}${index === members.length - 1 ? ';' : ''}`);
+    });
+    return lines;
+}
+function generateDiscriminatorFile(node, version, combo, props, schema, _importDepth = 5, variantSchemas = []) {
     const prefix = getPackagePrefix(node.name);
     const nodeName = prefix + toPascalCase(getNodeBaseName(node.name));
     const versionSuffix = versionToTypeName(version);
@@ -1976,23 +2100,35 @@ function generateDiscriminatorFile(node, version, combo, props, schema, _importD
             lines.push('');
         }
     }
-    lines.push(`export type ${nodeTypeName} = {`);
-    lines.push(`${INDENT}type: '${node.name}';`);
-    lines.push(`${INDENT}version: ${version};`);
-    if (isTrigger) {
-        lines.push(`${INDENT}isTrigger: true;`);
-    }
     const hasRequiredSubnodes = aiInputTypes.some((input) => input.required);
-    const configType = buildNodeConfigType(configName, {
-        credentialsTypeName: node.credentials && node.credentials.length > 0 ? 'Credentials' : undefined,
-        subnodeConfigTypeName: subnodeConfigTypeName ?? undefined,
-        subnodesRequired: hasRequiredSubnodes,
-    });
-    lines.push(`${INDENT}config: ${configType};`);
-    if (schema) {
-        lines.push(`${INDENT}output?: Items<${outputTypeName}>;`);
+    const nodeBody = (typeName, paramsConstraint, outputType) => {
+        const paramsType = paramsConstraint ? `${configName} & ${paramsConstraint}` : configName;
+        const configType = buildNodeConfigType(paramsType, {
+            credentialsTypeName: node.credentials && node.credentials.length > 0 ? 'Credentials' : undefined,
+            subnodeConfigTypeName: subnodeConfigTypeName ?? undefined,
+            subnodesRequired: hasRequiredSubnodes,
+        });
+        return [
+            `export type ${typeName} = {`,
+            `${INDENT}type: '${node.name}';`,
+            `${INDENT}version: ${version};`,
+            ...(isTrigger ? [`${INDENT}isTrigger: true;`] : []),
+            `${INDENT}config: ${configType};`,
+            ...(outputType ? [`${INDENT}output?: Items<${outputType}>;`] : []),
+            '};',
+        ];
+    };
+    const variants = schema ? resolveParameterVariants(props, variantSchemas) : undefined;
+    if (variants) {
+        lines.push(...generateParameterVariantTypes(variants, {
+            base: `${nodeName}${versionSuffix}${comboSuffix}`,
+            output: outputTypeName,
+            node: nodeTypeName,
+        }, nodeBody));
+    }
+    else {
+        lines.push(...nodeBody(nodeTypeName, undefined, schema ? outputTypeName : undefined));
     }
-    lines.push('};');
     return lines.join('\n');
 }
 function generateResourceIndexFile(node, version, resource, operations) {
@@ -2102,7 +2238,7 @@ function planSplitVersionFiles(node, version) {
                 const fileName = `operation_${toSnakeCase(operation)}.ts`;
                 const filePath = `${resourceDir}/${fileName}`;
                 const matchingSchema = findSchemaForOperation(outputSchemas, resource, operation);
-                const content = generateDiscriminatorFile(node, version, combo, props, matchingSchema?.schema, 6);
+                const content = generateDiscriminatorFile(node, version, combo, props, matchingSchema?.schema, 6, findVariantSchemasForOperation(outputSchemas, resource, operation));
                 files.set(filePath, content);
             }
             const filteredOperations = operations.filter((op) => !isCustomApiCall(op));