Hugging Face's logo

Spaces:
IBRAHIM1990
/
n8n-mcp
Sleeping

App Files Community
n8n-mcp
File size: 3,730 Bytes
da2e594
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/**
 * Generates example workflows and parameters for n8n nodes
 */
export class ExampleGenerator {
  /**
   * Generate an example workflow from node definition
   */
  static generateFromNodeDefinition(nodeDefinition: any): any {
    const nodeName = nodeDefinition.displayName || 'Example Node';
    const nodeType = nodeDefinition.name || 'n8n-nodes-base.exampleNode';
    
    return {
      name: `${nodeName} Example Workflow`,
      nodes: [
        {
          parameters: this.generateExampleParameters(nodeDefinition),
          id: this.generateNodeId(),
          name: nodeName,
          type: nodeType,
          typeVersion: nodeDefinition.version || 1,
          position: [250, 300],
        },
      ],
      connections: {},
      active: false,
      settings: {},
      tags: ['example', 'generated'],
    };
  }

  /**
   * Generate example parameters based on node properties
   */
  static generateExampleParameters(nodeDefinition: any): any {
    const params: any = {};
    
    // If properties are available, generate examples based on them
    if (Array.isArray(nodeDefinition.properties)) {
      for (const prop of nodeDefinition.properties) {
        if (prop.name && prop.type) {
          params[prop.name] = this.generateExampleValue(prop);
        }
      }
    }
    
    // Add common parameters based on node type
    if (nodeDefinition.displayName?.toLowerCase().includes('trigger')) {
      params.pollTimes = {
        item: [
          {
            mode: 'everyMinute',
          },
        ],
      };
    }
    
    return params;
  }

  /**
   * Generate example value based on property definition
   */
  private static generateExampleValue(property: any): any {
    switch (property.type) {
      case 'string':
        if (property.name.toLowerCase().includes('url')) {
          return 'https://example.com';
        }
        if (property.name.toLowerCase().includes('email')) {
          return 'user@example.com';
        }
        if (property.name.toLowerCase().includes('name')) {
          return 'Example Name';
        }
        return property.default || 'example-value';
        
      case 'number':
        return property.default || 10;
        
      case 'boolean':
        return property.default !== undefined ? property.default : true;
        
      case 'options':
        if (property.options && property.options.length > 0) {
          return property.options[0].value;
        }
        return property.default || '';
        
      case 'collection':
      case 'fixedCollection':
        return {};
        
      default:
        return property.default || null;
    }
  }

  /**
   * Generate a unique node ID
   */
  private static generateNodeId(): string {
    return Math.random().toString(36).substring(2, 15) + 
           Math.random().toString(36).substring(2, 15);
  }

  /**
   * Generate example based on node operations
   */
  static generateFromOperations(operations: any[]): any {
    const examples: any[] = [];
    
    if (!operations || operations.length === 0) {
      return examples;
    }
    
    // Group operations by resource
    const resourceMap = new Map<string, any[]>();
    for (const op of operations) {
      if (!resourceMap.has(op.resource)) {
        resourceMap.set(op.resource, []);
      }
      resourceMap.get(op.resource)!.push(op);
    }
    
    // Generate example for each resource
    for (const [resource, ops] of resourceMap) {
      examples.push({
        resource,
        operation: ops[0].operation,
        description: `Example: ${ops[0].description}`,
        parameters: {
          resource,
          operation: ops[0].operation,
        },
      });
    }
    
    return examples;
  }
}