Node Registry

GET /v1/gateway/custom-nodes/registry

X-API-Key: pk_sua_chave_aqui

{
  "nodes": [
    {
      "type": "input",
      "name": "User Input",
      "description": "Waits for user input and pauses workflow execution",
      "version": "1.0.0",
      "isBuiltIn": true,
      "inputSchema": {
        "data": {
          "type": "any",
          "description": "Input data to process",
          "required": true
        }
      },
      "outputSchema": {
        "result": {
          "type": "object",
          "description": "Processing result",
          "properties": {
            "success": { "type": "boolean" },
            "data": { "type": "any" }
          }
        }
      },
      "configSchema": {
        "timeout": {
          "type": "number",
          "description": "Timeout in milliseconds",
          "min": 1000,
          "max": 300000,
          "default": 30000
        }
      },
      "canPause": true
    },
    {
      "type": "custom-api-call",
      "name": "Custom API Call",
      "description": "Custom node example",
      "version": "1.0.0",
      "isBuiltIn": false,
      "inputSchema": {
        "data": {
          "type": "any",
          "description": "Input data to process",
          "required": true
        }
      },
      "outputSchema": {
        "result": {
          "type": "object",
          "description": "API call result"
        }
      },
      "configSchema": {
        "endpoint": {
          "type": "string",
          "description": "API endpoint URL",
          "required": true
        },
        "method": {
          "type": "enum",
          "enum": ["GET", "POST", "PUT", "DELETE"],
          "default": "POST"
        }
      },
      "canPause": false
    }
  ],
  "total": 7
}

npm install triglit

import Triglit from 'triglit';

// 1. Inicializar o cliente do SDK
const client = new Triglit({ 
  apiKey: 'pk_sua_chave_aqui' 
});

// 2. Buscar o registry usando o SDK
const registry = await client.customNodes.retrieveRegistry();

// 3. Renderizar lista de nodes disponíveis
function NodePalette({ registry }) {
  return (
    <div className="node-palette">
      <h3>Nodes Disponíveis</h3>
      {registry.nodes.map(node => (
        <NodeCard
          key={node.type}
          type={node.type}
          name={node.name}
          description={node.description}
          isBuiltIn={node.isBuiltIn}
          onClick={() => addNodeToWorkflow(node.type)}
        />
      ))}
    </div>
  );
}

// 4. Renderizar formulário de configuração do node
function NodeConfigForm({ nodeType, registry }) {
  const node = registry.nodes.find(n => n.type === nodeType);
  if (!node || !node.configSchema) return null;

  return (
    <form>
      {Object.entries(node.configSchema).map(([fieldName, fieldSchema]) => (
        <FieldInput
          key={fieldName}
          name={fieldName}
          schema={fieldSchema}
          // Renderiza input baseado no tipo e validações
        />
      ))}
    </form>
  );
}

// 5. Validar configuração antes de salvar
function validateNodeConfig(nodeType, config, registry) {
  const node = registry.nodes.find(n => n.type === nodeType);
  if (!node || !node.configSchema) return { valid: true };

  const errors = {};
  for (const [fieldName, fieldSchema] of Object.entries(node.configSchema)) {
    const value = config[fieldName];
    
    // Validar required
    if (fieldSchema.required && (value === undefined || value === null)) {
      errors[fieldName] = 'Campo obrigatório';
      continue;
    }

    // Validar tipo
    if (value !== undefined && !validateType(value, fieldSchema.type)) {
      errors[fieldName] = `Tipo inválido. Esperado: ${fieldSchema.type}`;
      continue;
    }

    // Validar constraints específicas do tipo
    if (fieldSchema.type === 'string') {
      if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
        errors[fieldName] = `Mínimo ${fieldSchema.minLength} caracteres`;
      }
      if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
        errors[fieldName] = `Máximo ${fieldSchema.maxLength} caracteres`;
      }
      if (fieldSchema.pattern && !new RegExp(fieldSchema.pattern).test(value)) {
        errors[fieldName] = 'Formato inválido';
      }
    }

    if (fieldSchema.type === 'number') {
      if (fieldSchema.min !== undefined && value < fieldSchema.min) {
        errors[fieldName] = `Valor mínimo: ${fieldSchema.min}`;
      }
      if (fieldSchema.max !== undefined && value > fieldSchema.max) {
        errors[fieldName] = `Valor máximo: ${fieldSchema.max}`;
      }
      if (fieldSchema.integer && !Number.isInteger(value)) {
        errors[fieldName] = 'Deve ser um número inteiro';
      }
    }

    if (fieldSchema.type === 'enum' && !fieldSchema.enum?.includes(value)) {
      errors[fieldName] = `Valor deve ser um de: ${fieldSchema.enum.join(', ')}`;
    }
  }

  return {
    valid: Object.keys(errors).length === 0,
    errors
  };
}

import { WorkflowEditor } from '@triglit/react-sdk';

function MyWorkflowEditor() {
  return (
    <WorkflowEditor
      apiKey="pk_sua_chave_aqui"
      // O SDK busca automaticamente o registry e renderiza os nodes
      onNodeAdd={(nodeType) => console.log('Node adicionado:', nodeType)}
    />
  );
}

import Triglit from 'triglit';

const client = new Triglit({ apiKey: 'pk_sua_chave_aqui' });

try {
  const registry = await client.customNodes.retrieveRegistry();
  // Usar registry
} catch (error) {
  if (error.status === 401) {
    // Chave de API inválida
  } else if (error.status === 429) {
    // Rate limit excedido
  } else {
    // Erro do servidor
  }
}

import Triglit from 'triglit';
import type { CustomNodeRetrieveRegistryResponse } from 'triglit';

// service/node-registry.service.ts
class NodeRegistryService {
  private client: Triglit;
  private cache: CustomNodeRetrieveRegistryResponse | null = null;
  private cacheExpiry: number = 0;
  private readonly CACHE_TTL = 5 * 60 * 1000; // 5 minutos

  constructor(apiKey: string) {
    this.client = new Triglit({ apiKey });
  }

  async getRegistry(forceRefresh = false): Promise<CustomNodeRetrieveRegistryResponse> {
    const now = Date.now();
    
    if (!forceRefresh && this.cache && now < this.cacheExpiry) {
      return this.cache;
    }

    try {
      this.cache = await this.client.customNodes.retrieveRegistry();
      this.cacheExpiry = now + this.CACHE_TTL;
      return this.cache;
    } catch (error) {
      throw new Error(`Failed to fetch registry: ${error.message}`);
    }
  }

  invalidateCache() {
    this.cache = null;
    this.cacheExpiry = 0;
  }

  findNode(
    type: string, 
    registry: CustomNodeRetrieveRegistryResponse
  ): CustomNodeRetrieveRegistryResponse['nodes'][0] | undefined {
    return registry.nodes.find(node => node.type === type);
  }

  validateConfig(
    nodeType: string,
    config: Record<string, unknown>,
    registry: CustomNodeRetrieveRegistryResponse
  ): { valid: boolean; errors: Record<string, string> } {
    const node = this.findNode(nodeType, registry);
    if (!node || !node.configSchema) {
      return { valid: true, errors: {} };
    }

    const errors: Record<string, string> = {};
    
    for (const [fieldName, fieldSchema] of Object.entries(node.configSchema)) {
      const value = config[fieldName];
      
      // Validar required
      if (fieldSchema.required && (value === undefined || value === null)) {
        errors[fieldName] = 'Campo obrigatório';
        continue;
      }

      // Validar tipo
      if (value !== undefined && !this.validateType(value, fieldSchema.type)) {
        errors[fieldName] = `Tipo inválido. Esperado: ${fieldSchema.type}`;
        continue;
      }

      // Validar constraints específicas do tipo
      if (fieldSchema.type === 'string' && typeof value === 'string') {
        if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
          errors[fieldName] = `Mínimo ${fieldSchema.minLength} caracteres`;
        }
        if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
          errors[fieldName] = `Máximo ${fieldSchema.maxLength} caracteres`;
        }
        if (fieldSchema.pattern && !new RegExp(fieldSchema.pattern).test(value)) {
          errors[fieldName] = 'Formato inválido';
        }
      }

      if (fieldSchema.type === 'number' && typeof value === 'number') {
        if (fieldSchema.min !== undefined && value < fieldSchema.min) {
          errors[fieldName] = `Valor mínimo: ${fieldSchema.min}`;
        }
        if (fieldSchema.max !== undefined && value > fieldSchema.max) {
          errors[fieldName] = `Valor máximo: ${fieldSchema.max}`;
        }
        if (fieldSchema.integer && !Number.isInteger(value)) {
          errors[fieldName] = 'Deve ser um número inteiro';
        }
      }

      if (fieldSchema.type === 'enum' && !fieldSchema.enum?.includes(value)) {
        errors[fieldName] = `Valor deve ser um de: ${fieldSchema.enum?.join(', ')}`;
      }
    }

    return {
      valid: Object.keys(errors).length === 0,
      errors
    };
  }

  private validateType(value: unknown, type: string): boolean {
    switch (type) {
      case 'string':
        return typeof value === 'string';
      case 'number':
        return typeof value === 'number';
      case 'boolean':
        return typeof value === 'boolean';
      case 'any':
        return true;
      case 'object':
        return typeof value === 'object' && value !== null && !Array.isArray(value);
      case 'array':
        return Array.isArray(value);
      default:
        return false;
    }
  }
}

// Uso
const service = new NodeRegistryService('pk_sua_chave_aqui');
const registry = await service.getRegistry();
const node = service.findNode('input', registry);
const validation = service.validateConfig('input', { timeout: 30000 }, registry);