ros/n8n-mcp
1
0
Fork 0
mirror of https://github.com/czlonkowski/n8n-mcp.git synced 2026-02-06 13:33:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add TypeScript type safety with strategic any assertions (v2.17.5)

Browse Source 
Added comprehensive TypeScript type definitions for n8n node parsing while
maintaining zero compilation errors. Uses pragmatic "70% benefit with 0%
breakage" approach with strategic `any` assertions.

## Type Definitions (src/types/node-types.ts)
- NodeClass union type replaces `any` in method signatures
- Type guards: isVersionedNodeInstance(), isVersionedNodeClass()
- Utility functions for safe node handling

## Parser Updates
- node-parser.ts: All methods use NodeClass (15+ methods)
- simple-parser.ts: Strongly typed method signatures
- property-extractor.ts: Typed extraction methods
- 30+ method signatures improved

## Strategic Pattern
- Strong types in public method signatures (caller type safety)
- Strategic `as any` assertions for internal union type access
- Pattern: const desc = description as any; // Access union properties

## Benefits
- Better IDE support and auto-complete
- Compile-time safety at call sites
- Type-based documentation
- Zero compilation errors
- Bug prevention (would have caught v2.17.4 baseDescription issue)

## Test Updates
- All test files updated with `as any` for mock objects
- Zero compilation errors maintained

## Known Limitations
- ~70% type coverage (signatures typed, internal logic uses assertions)
- Union types (INodeTypeBaseDescription vs INodeTypeDescription) not fully resolved
- Future work: Conditional types or overloads for 100% type safety

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
czlonkowski
2025-10-07 22:16:59 +02:00
parent 8e2e1dce62
commit f3164e202f
15 changed files with 1293 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
src/parsers/node-parser.ts
View File

@@ -1,4 +1,14 @@
import { PropertyExtractor } from './property-extractor';
import type {
NodeClass,
VersionedNodeInstance
} from '../types/node-types';
import {
isVersionedNodeInstance,
isVersionedNodeClass,
getNodeDescription as getNodeDescriptionHelper
} from '../types/node-types';
import type { INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
export interface ParsedNode {
style: 'declarative' | 'programmatic';
@@ -22,9 +32,9 @@ export interface ParsedNode {
export class NodeParser {
private propertyExtractor = new PropertyExtractor();
private currentNodeClass: any = null;
parse(nodeClass: any, packageName: string): ParsedNode {
private currentNodeClass: NodeClass | null = null;
parse(nodeClass: NodeClass, packageName: string): ParsedNode {
this.currentNodeClass = nodeClass;
// Get base description (handles versioned nodes)
const description = this.getNodeDescription(nodeClass);
@@ -50,46 +60,43 @@ export class NodeParser {
};
}
private getNodeDescription(nodeClass: any): any {
private getNodeDescription(nodeClass: NodeClass): INodeTypeBaseDescription | INodeTypeDescription {
// Try to get description from the class first
let description: any;
// Check if it's a versioned node (has baseDescription and nodeVersions)
if (typeof nodeClass === 'function' && nodeClass.prototype &&
nodeClass.prototype.constructor &&
nodeClass.prototype.constructor.name === 'VersionedNodeType') {
let description: INodeTypeBaseDescription | INodeTypeDescription | undefined;
// Check if it's a versioned node using type guard
if (isVersionedNodeClass(nodeClass)) {
// This is a VersionedNodeType class - instantiate it
const instance = new nodeClass();
description = instance.baseDescription || {};
try {
const instance = new (nodeClass as new () => VersionedNodeInstance)();
description = instance.description;
} catch (e) {
// Some nodes might require parameters to instantiate
}
} else if (typeof nodeClass === 'function') {
// Try to instantiate to get description
try {
const instance = new nodeClass();
description = instance.description || {};
// For versioned nodes, we might need to look deeper
if (!description.name && instance.baseDescription) {
description = instance.baseDescription;
}
description = instance.description;
} catch (e) {
// Some nodes might require parameters to instantiate
// Try to access static properties
description = nodeClass.description || {};
description = (nodeClass as any).description;
}
} else {
// Maybe it's already an instance
description = nodeClass.description || {};
description = nodeClass.description;
}
return description;
return description || ({} as any);
}
private detectStyle(nodeClass: any): 'declarative' | 'programmatic' {
private detectStyle(nodeClass: NodeClass): 'declarative' | 'programmatic' {
const desc = this.getNodeDescription(nodeClass);
return desc.routing ? 'declarative' : 'programmatic';
return (desc as any).routing ? 'declarative' : 'programmatic';
}
private extractNodeType(description: any, packageName: string): string {
private extractNodeType(description: INodeTypeBaseDescription | INodeTypeDescription, packageName: string): string {
// Ensure we have the full node type including package prefix
const name = description.name;
@@ -106,31 +113,35 @@ export class NodeParser {
return `${packagePrefix}.${name}`;
}
private extractCategory(description: any): string {
return description.group?.[0] ||
description.categories?.[0] ||
description.category ||
private extractCategory(description: INodeTypeBaseDescription | INodeTypeDescription): string {
return description.group?.[0] ||
(description as any).categories?.[0] ||
(description as any).category ||
'misc';
}
private detectTrigger(description: any): boolean {
private detectTrigger(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
// Strategic any assertion for properties that only exist on INodeTypeDescription
const desc = description as any;
// Primary check: group includes 'trigger'
if (description.group && Array.isArray(description.group)) {
if (description.group.includes('trigger')) {
return true;
}
}
// Fallback checks for edge cases
return description.polling === true ||
description.trigger === true ||
description.eventTrigger === true ||
return desc.polling === true ||
desc.trigger === true ||
desc.eventTrigger === true ||
description.name?.toLowerCase().includes('trigger');
}
private detectWebhook(description: any): boolean {
return (description.webhooks?.length > 0) ||
description.webhook === true ||
private detectWebhook(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
const desc = description as any; // INodeTypeDescription has webhooks, but INodeTypeBaseDescription doesn't
return (desc.webhooks?.length > 0) ||
desc.webhook === true ||
description.name?.toLowerCase().includes('webhook');
}
@@ -152,35 +163,47 @@ export class NodeParser {
* @param nodeClass - The node class or instance to extract version from
* @returns The version as a string
*/
private extractVersion(nodeClass: any): string {
private extractVersion(nodeClass: NodeClass): string {
// Check instance properties first
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion - instance could be INodeType or IVersionedNodeType
const inst = instance as any;
// PRIORITY 1: Check currentVersion (what VersionedNodeType actually uses)
// For VersionedNodeType, currentVersion = defaultVersion ?? max(nodeVersions)
if (instance?.currentVersion !== undefined) {
return instance.currentVersion.toString();
if (inst?.currentVersion !== undefined) {
return inst.currentVersion.toString();
}
// PRIORITY 2: Handle instance-level description.defaultVersion
// VersionedNodeType stores baseDescription as 'description', not 'baseDescription'
if (instance?.description?.defaultVersion) {
return instance.description.defaultVersion.toString();
if (inst?.description?.defaultVersion) {
return inst.description.defaultVersion.toString();
}
// PRIORITY 3: Handle instance-level nodeVersions (fallback to max)
if (instance?.nodeVersions) {
const versions = Object.keys(instance.nodeVersions);
return Math.max(...versions.map(Number)).toString();
if (inst?.nodeVersions) {
const versions = Object.keys(inst.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// Handle version array in description (e.g., [1, 1.1, 1.2])
if (instance?.description?.version) {
const version = instance.description.version;
if (inst?.description?.version) {
const version = inst.description.version;
if (Array.isArray(version)) {
const maxVersion = Math.max(...version.map((v: any) => parseFloat(v.toString())));
return maxVersion.toString();
const numericVersions = version.map((v: any) => parseFloat(v.toString()));
if (numericVersions.length > 0) {
const maxVersion = Math.max(...numericVersions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
} else if (typeof version === 'number' || typeof version === 'string') {
return version.toString();
}
@@ -192,24 +215,37 @@ export class NodeParser {
// Handle class-level VersionedNodeType with defaultVersion
// Note: Most VersionedNodeType classes don't have static properties
if (nodeClass.description?.defaultVersion) {
return nodeClass.description.defaultVersion.toString();
// Strategic any assertion for class-level property access
const nodeClassAny = nodeClass as any;
if (nodeClassAny.description?.defaultVersion) {
return nodeClassAny.description.defaultVersion.toString();
}
// Handle class-level VersionedNodeType with nodeVersions
if (nodeClass.nodeVersions) {
const versions = Object.keys(nodeClass.nodeVersions);
return Math.max(...versions.map(Number)).toString();
if (nodeClassAny.nodeVersions) {
const versions = Object.keys(nodeClassAny.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// Also check class-level description for version array
const description = this.getNodeDescription(nodeClass);
if (description?.version) {
if (Array.isArray(description.version)) {
const maxVersion = Math.max(...description.version.map((v: any) => parseFloat(v.toString())));
return maxVersion.toString();
} else if (typeof description.version === 'number' || typeof description.version === 'string') {
return description.version.toString();
const desc = description as any; // Strategic assertion for version property
if (desc?.version) {
if (Array.isArray(desc.version)) {
const numericVersions = desc.version.map((v: any) => parseFloat(v.toString()));
if (numericVersions.length > 0) {
const maxVersion = Math.max(...numericVersions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
} else if (typeof desc.version === 'number' || typeof desc.version === 'string') {
return desc.version.toString();
}
}
@@ -217,67 +253,78 @@ export class NodeParser {
return '1';
}
private detectVersioned(nodeClass: any): boolean {
private detectVersioned(nodeClass: NodeClass): boolean {
// Check instance-level properties first
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion - instance could be INodeType or IVersionedNodeType
const inst = instance as any;
// Check for instance baseDescription with defaultVersion
if (instance?.baseDescription?.defaultVersion) {
if (inst?.baseDescription?.defaultVersion) {
return true;
}
// Check for nodeVersions
if (instance?.nodeVersions) {
if (inst?.nodeVersions) {
return true;
}
// Check for version array in description
if (instance?.description?.version && Array.isArray(instance.description.version)) {
if (inst?.description?.version && Array.isArray(inst.description.version)) {
return true;
}
} catch (e) {
// Some nodes might require parameters to instantiate
// Try class-level checks
}
// Check class-level nodeVersions
if (nodeClass.nodeVersions || nodeClass.baseDescription?.defaultVersion) {
// Strategic any assertion for class-level property access
const nodeClassAny = nodeClass as any;
if (nodeClassAny.nodeVersions || nodeClassAny.baseDescription?.defaultVersion) {
return true;
}
// Also check class-level description for version array
const description = this.getNodeDescription(nodeClass);
if (description?.version && Array.isArray(description.version)) {
const desc = description as any; // Strategic assertion for version property
if (desc?.version && Array.isArray(desc.version)) {
return true;
}
return false;
}
private extractOutputs(description: any): { outputs?: any[], outputNames?: string[] } {
private extractOutputs(description: INodeTypeBaseDescription | INodeTypeDescription): { outputs?: any[], outputNames?: string[] } {
const result: { outputs?: any[], outputNames?: string[] } = {};
// Strategic any assertion for outputs/outputNames properties
const desc = description as any;
// First check the base description
if (description.outputs) {
result.outputs = Array.isArray(description.outputs) ? description.outputs : [description.outputs];
if (desc.outputs) {
result.outputs = Array.isArray(desc.outputs) ? desc.outputs : [desc.outputs];
}
if (description.outputNames) {
result.outputNames = Array.isArray(description.outputNames) ? description.outputNames : [description.outputNames];
if (desc.outputNames) {
result.outputNames = Array.isArray(desc.outputNames) ? desc.outputNames : [desc.outputNames];
}
// If no outputs found and this is a versioned node, check the latest version
if (!result.outputs && !result.outputNames) {
const nodeClass = this.currentNodeClass; // We'll need to track this
if (nodeClass) {
try {
const instance = new nodeClass();
if (instance.nodeVersions) {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion for instance properties
const inst = instance as any;
if (inst.nodeVersions) {
// Get the latest version
const versions = Object.keys(instance.nodeVersions).map(Number);
const latestVersion = Math.max(...versions);
const versionedDescription = instance.nodeVersions[latestVersion]?.description;
const versions = Object.keys(inst.nodeVersions).map(Number);
if (versions.length > 0) {
const latestVersion = Math.max(...versions);
if (!isNaN(latestVersion)) {
const versionedDescription = inst.nodeVersions[latestVersion]?.description;
if (versionedDescription) {
if (versionedDescription.outputs) {
@@ -287,11 +334,13 @@ export class NodeParser {
}
if (versionedDescription.outputNames) {
result.outputNames = Array.isArray(versionedDescription.outputNames)
? versionedDescription.outputNames
result.outputNames = Array.isArray(versionedDescription.outputNames)
? versionedDescription.outputNames
: [versionedDescription.outputNames];
}
}
}
}
}
} catch (e) {
// Ignore errors from instantiating node

92
src/parsers/property-extractor.ts
View File

@@ -1,8 +1,10 @@
import type { NodeClass } from '../types/node-types';
export class PropertyExtractor {
/**
* Extract properties with proper handling of n8n's complex structures
*/
extractProperties(nodeClass: any): any[] {
extractProperties(nodeClass: NodeClass): any[] {
const properties: any[] = [];
// First try to get instance-level properties
@@ -15,12 +17,16 @@ export class PropertyExtractor {
// Handle versioned nodes - check instance for nodeVersions
if (instance?.nodeVersions) {
const versions = Object.keys(instance.nodeVersions);
const latestVersion = Math.max(...versions.map(Number));
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description?.properties) {
return this.normalizeProperties(versionedNode.description.properties);
const versions = Object.keys(instance.nodeVersions).map(Number);
if (versions.length > 0) {
const latestVersion = Math.max(...versions);
if (!isNaN(latestVersion)) {
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description?.properties) {
return this.normalizeProperties(versionedNode.description.properties);
}
}
}
}
@@ -35,30 +41,36 @@ export class PropertyExtractor {
return properties;
}
private getNodeDescription(nodeClass: any): any {
private getNodeDescription(nodeClass: NodeClass): any {
// Try to get description from the class first
let description: any;
if (typeof nodeClass === 'function') {
// Try to instantiate to get description
try {
const instance = new nodeClass();
description = instance.description || instance.baseDescription || {};
// Strategic any assertion for instance properties
const inst = instance as any;
description = inst.description || inst.baseDescription || {};
} catch (e) {
// Some nodes might require parameters to instantiate
description = nodeClass.description || {};
// Strategic any assertion for class-level properties
const nodeClassAny = nodeClass as any;
description = nodeClassAny.description || {};
}
} else {
description = nodeClass.description || {};
// Strategic any assertion for instance properties
const inst = nodeClass as any;
description = inst.description || {};
}
return description;
}
/**
* Extract operations from both declarative and programmatic nodes
*/
extractOperations(nodeClass: any): any[] {
extractOperations(nodeClass: NodeClass): any[] {
const operations: any[] = [];
// First try to get instance-level data
@@ -71,12 +83,16 @@ export class PropertyExtractor {
// Handle versioned nodes
if (instance?.nodeVersions) {
const versions = Object.keys(instance.nodeVersions);
const latestVersion = Math.max(...versions.map(Number));
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description) {
return this.extractOperationsFromDescription(versionedNode.description);
const versions = Object.keys(instance.nodeVersions).map(Number);
if (versions.length > 0) {
const latestVersion = Math.max(...versions);
if (!isNaN(latestVersion)) {
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description) {
return this.extractOperationsFromDescription(versionedNode.description);
}
}
}
}
@@ -138,33 +154,35 @@ export class PropertyExtractor {
/**
* Deep search for AI tool capability
*/
detectAIToolCapability(nodeClass: any): boolean {
detectAIToolCapability(nodeClass: NodeClass): boolean {
const description = this.getNodeDescription(nodeClass);
// Direct property check
if (description?.usableAsTool === true) return true;
// Check in actions for declarative nodes
if (description?.actions?.some((a: any) => a.usableAsTool === true)) return true;
// Check versioned nodes
if (nodeClass.nodeVersions) {
for (const version of Object.values(nodeClass.nodeVersions)) {
// Strategic any assertion for nodeVersions property
const nodeClassAny = nodeClass as any;
if (nodeClassAny.nodeVersions) {
for (const version of Object.values(nodeClassAny.nodeVersions)) {
if ((version as any).description?.usableAsTool === true) return true;
}
}
// Check for specific AI-related properties
const aiIndicators = ['openai', 'anthropic', 'huggingface', 'cohere', 'ai'];
const nodeName = description?.name?.toLowerCase() || '';
return aiIndicators.some(indicator => nodeName.includes(indicator));
}
/**
* Extract credential requirements with proper structure
*/
extractCredentials(nodeClass: any): any[] {
extractCredentials(nodeClass: NodeClass): any[] {
const credentials: any[] = [];
// First try to get instance-level data
@@ -177,12 +195,16 @@ export class PropertyExtractor {
// Handle versioned nodes
if (instance?.nodeVersions) {
const versions = Object.keys(instance.nodeVersions);
const latestVersion = Math.max(...versions.map(Number));
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description?.credentials) {
return versionedNode.description.credentials;
const versions = Object.keys(instance.nodeVersions).map(Number);
if (versions.length > 0) {
const latestVersion = Math.max(...versions);
if (!isNaN(latestVersion)) {
const versionedNode = instance.nodeVersions[latestVersion];
if (versionedNode?.description?.credentials) {
return versionedNode.description.credentials;
}
}
}
}

176
src/parsers/simple-parser.ts
View File

@@ -1,3 +1,13 @@
import type {
NodeClass,
VersionedNodeInstance
} from '../types/node-types';
import {
isVersionedNodeInstance,
isVersionedNodeClass
} from '../types/node-types';
import type { INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
export interface ParsedNode {
style: 'declarative' | 'programmatic';
nodeType: string;
@@ -15,21 +25,19 @@ export interface ParsedNode {
}
export class SimpleParser {
parse(nodeClass: any): ParsedNode {
let description: any;
parse(nodeClass: NodeClass): ParsedNode {
let description: INodeTypeBaseDescription | INodeTypeDescription;
let isVersioned = false;
// Try to get description from the class
try {
// Check if it's a versioned node (has baseDescription and nodeVersions)
if (typeof nodeClass === 'function' && nodeClass.prototype &&
nodeClass.prototype.constructor &&
nodeClass.prototype.constructor.name === 'VersionedNodeType') {
// Check if it's a versioned node using type guard
if (isVersionedNodeClass(nodeClass)) {
// This is a VersionedNodeType class - instantiate it
const instance = new nodeClass();
description = instance.baseDescription || {};
const instance = new (nodeClass as new () => VersionedNodeInstance)();
description = instance.description;
isVersioned = true;
// For versioned nodes, try to get properties from the current version
if (instance.nodeVersions && instance.currentVersion) {
const currentVersionNode = instance.nodeVersions[instance.currentVersion];
@@ -42,63 +50,62 @@ export class SimpleParser {
// Try to instantiate to get description
try {
const instance = new nodeClass();
description = instance.description || {};
// For versioned nodes, we might need to look deeper
if (!description.name && instance.baseDescription) {
description = instance.baseDescription;
isVersioned = true;
}
description = instance.description;
} catch (e) {
// Some nodes might require parameters to instantiate
// Try to access static properties or look for common patterns
description = {};
description = {} as any;
}
} else {
// Maybe it's already an instance
description = nodeClass.description || {};
description = nodeClass.description;
}
} catch (error) {
// If instantiation fails, try to get static description
description = nodeClass.description || {};
description = (nodeClass as any).description || ({} as any);
}
const isDeclarative = !!description.routing;
// Strategic any assertion for properties that don't exist on both union sides
const desc = description as any;
const isDeclarative = !!desc.routing;
// Ensure we have a valid nodeType
if (!description.name) {
throw new Error('Node is missing name property');
}
return {
style: isDeclarative ? 'declarative' : 'programmatic',
nodeType: description.name,
displayName: description.displayName || description.name,
description: description.description,
category: description.group?.[0] || description.categories?.[0],
properties: description.properties || [],
credentials: description.credentials || [],
isAITool: description.usableAsTool === true,
category: description.group?.[0] || desc.categories?.[0],
properties: desc.properties || [],
credentials: desc.credentials || [],
isAITool: desc.usableAsTool === true,
isTrigger: this.detectTrigger(description),
isWebhook: description.webhooks?.length > 0,
operations: isDeclarative ? this.extractOperations(description.routing) : this.extractProgrammaticOperations(description),
isWebhook: desc.webhooks?.length > 0,
operations: isDeclarative ? this.extractOperations(desc.routing) : this.extractProgrammaticOperations(desc),
version: this.extractVersion(nodeClass),
isVersioned: isVersioned || this.isVersionedNode(nodeClass) || Array.isArray(description.version) || description.defaultVersion !== undefined
isVersioned: isVersioned || this.isVersionedNode(nodeClass) || Array.isArray(desc.version) || desc.defaultVersion !== undefined
};
}
private detectTrigger(description: any): boolean {
private detectTrigger(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
// Primary check: group includes 'trigger'
if (description.group && Array.isArray(description.group)) {
if (description.group.includes('trigger')) {
return true;
}
}
// Strategic any assertion for properties that only exist on INodeTypeDescription
const desc = description as any;
// Fallback checks for edge cases
return description.polling === true ||
description.trigger === true ||
description.eventTrigger === true ||
return desc.polling === true ||
desc.trigger === true ||
desc.eventTrigger === true ||
description.name?.toLowerCase().includes('trigger');
}
@@ -186,48 +193,103 @@ export class SimpleParser {
return operations;
}
private extractVersion(nodeClass: any): string {
/**
* Extracts the version from a node class.
*
* Priority Chain (same as node-parser.ts):
* 1. Instance currentVersion (VersionedNodeType's computed property)
* 2. Instance description.defaultVersion (explicit default)
* 3. Instance nodeVersions (fallback to max available version)
* 4. Instance description.version (simple versioning)
* 5. Class-level properties (if instantiation fails)
* 6. Default to "1"
*
* Critical Fix (v2.17.4): Removed check for non-existent instance.baseDescription.defaultVersion
* which caused AI Agent and other VersionedNodeType nodes to return wrong versions.
*
* @param nodeClass - The node class or instance to extract version from
* @returns The version as a string
*/
private extractVersion(nodeClass: NodeClass): string {
// Try to get version from instance first
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Check instance baseDescription
if (instance?.baseDescription?.defaultVersion) {
return instance.baseDescription.defaultVersion.toString();
// Strategic any assertion for instance properties
const inst = instance as any;
// PRIORITY 1: Check currentVersion (what VersionedNodeType actually uses)
// For VersionedNodeType, currentVersion = defaultVersion ?? max(nodeVersions)
if (inst?.currentVersion !== undefined) {
return inst.currentVersion.toString();
}
// Check instance description version
if (instance?.description?.version) {
return instance.description.version.toString();
// PRIORITY 2: Handle instance-level description.defaultVersion
// VersionedNodeType stores baseDescription as 'description', not 'baseDescription'
if (inst?.description?.defaultVersion) {
return inst.description.defaultVersion.toString();
}
// PRIORITY 3: Handle instance-level nodeVersions (fallback to max)
if (inst?.nodeVersions) {
const versions = Object.keys(inst.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// PRIORITY 4: Check instance description version
if (inst?.description?.version) {
return inst.description.version.toString();
}
} catch (e) {
// Ignore instantiation errors
}
// Check class-level properties
if (nodeClass.baseDescription?.defaultVersion) {
return nodeClass.baseDescription.defaultVersion.toString();
// PRIORITY 5: Check class-level properties (if instantiation failed)
// Strategic any assertion for class-level properties
const nodeClassAny = nodeClass as any;
if (nodeClassAny.description?.defaultVersion) {
return nodeClassAny.description.defaultVersion.toString();
}
return nodeClass.description?.version || '1';
if (nodeClassAny.nodeVersions) {
const versions = Object.keys(nodeClassAny.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// PRIORITY 6: Default to version 1
return nodeClassAny.description?.version || '1';
}
private isVersionedNode(nodeClass: any): boolean {
private isVersionedNode(nodeClass: NodeClass): boolean {
// Strategic any assertion for class-level properties
const nodeClassAny = nodeClass as any;
// Check for VersionedNodeType pattern
if (nodeClass.baseDescription && nodeClass.nodeVersions) {
if (nodeClassAny.baseDescription && nodeClassAny.nodeVersions) {
return true;
}
// Check for inline versioning pattern (like Code node)
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
const description = instance.description || {};
// Strategic any assertion for instance properties
const inst = instance as any;
const description = inst.description || {};
// If version is an array, it's versioned
if (Array.isArray(description.version)) {
return true;
}
// If it has defaultVersion, it's likely versioned
if (description.defaultVersion !== undefined) {
return true;
@@ -235,7 +297,7 @@ export class SimpleParser {
} catch (e) {
// Ignore instantiation errors
}
return false;
}
}