n8n-io/n8n · error · UnsupportedNodeError

Unsupported syntax: 'super keyword is not supported in SDK c

Error message

Unsupported syntax: 'super keyword is not supported in SDK code' is not allowed in SDK code

What it means

The `super` keyword (class inheritance) has no meaning in SDK builder code — there are no classes — and is explicitly rejected when it appears as the object of a member expression call (`super.method()`). This check at interpreter.ts:227 is defense-in-depth: `ClassDeclaration` and `ClassExpression` are already in `FORBIDDEN_NODE_TYPES`, so `super` should never reach the call visitor, but this catches any path that slips through.

Source

Thrown at packages/@n8n/workflow-sdk/src/ast-interpreter/interpreter.ts:228

			if (this.sdkFunctions.has(name)) {
				func = this.sdkFunctions.get(name);
			} else {
				// Check variables, including auto-renamed ones
				const resolvedName = this.renamedVariables.get(name) ?? name;
				if (this.variables.has(resolvedName)) {
					func = this.variables.get(resolvedName);
				} else {
					throw new UnknownIdentifierError(name, node.callee.loc ?? undefined, this.sourceCode);
				}
			}
		} else if (node.callee.type === 'MemberExpression') {
			// Method call: wf.add(...), node.to(...), etc.
			const memberExpr = node.callee;
			validateMemberExpression(memberExpr, this.sourceCode);

			// Handle Super type (super keyword) - not supported in SDK code
			if (memberExpr.object.type === 'Super') {
				throw new UnsupportedNodeError(
					'super keyword is not supported in SDK code',
					memberExpr.object.loc ?? undefined,
					this.sourceCode,
				);
			}

			// Get method name
			let methodName: string;
			if (memberExpr.property.type === 'Identifier') {
				methodName = memberExpr.property.name;
			} else if (
				memberExpr.property.type === 'Literal' &&
				typeof memberExpr.property.value === 'string'
			) {
				methodName = memberExpr.property.value;
			} else {
				throw new UnsupportedNodeError(
					'Dynamic method name',

View on GitHub (pinned to 5ac6606e81)

Solutions

1. Remove the `super` call entirely — SDK code has no class hierarchy
2. If you need the inherited behavior, inline the logic directly or move it to a Code node

Example fix

// before
super.configure();

// after
// (remove — SDK code supports no classes or super keyword)

// Reject class syntax (which produces super) before interpreting
function hasSuperKeyword(code: string): boolean {
  const ast = parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
  let found = false;
  walk(ast, (node) => {
    if (node.type === 'Super') found = true;
  });
  return found;
}

if (hasSuperKeyword(sdkCode)) {
  // reject — SDK code supports no classes

import { UnsupportedNodeError } from '@n8n/workflow-sdk/ast-interpreter/errors';

try {
  interpretSDKCode(sdkCode, sdkFunctions);
} catch (e) {
  if (e instanceof UnsupportedNodeError && e.message.includes('super keyword')) {
    // instruct user to remove class/super usage
  }
  throw e;
}

When it happens

Trigger: Writing `super.configure()` in SDK code. In practice unreachable through valid SDK code because class syntax is blocked at the `validateNodeType` stage, but serves as a secondary guard.

Common situations: Copying code from a class-based TypeScript snippet into SDK builder code; generated code that includes class inheritance patterns.

Related errors

• Unsupported syntax: 'Logical operator ${String(node.operator
• Unsupported syntax: 'Destructuring in variable declaration'
• '${name}' is a reserved SDK function name and cannot be used
• Expression nesting too deep (possible cycle in method chain)
• Unknown identifier: '${identifier}' is not defined

AI-assisted analysis of n8n-io/n8n@5ac6606e81 (2026-08-12). Data as JSON: /api/errors/caa3888e37e26ee4. Report an issue: GitHub.