Pular para conteúdo

MONGODB FIND - Buscar Documentos no MongoDB

O que é este Node?

O MONGODB FIND é o node responsável por buscar múltiplos documentos em uma coleção MongoDB com suporte a filtros, ordenação, paginação e limites.

Por que este Node existe?

Ao trabalhar com bancos de dados NoSQL como MongoDB, você precisa buscar múltiplos registros que atendam a critérios específicos. O MONGODB FIND existe para:

  1. Buscar múltiplos documentos: Recuperar vários registros de uma vez
  2. Filtrar dados: Aplicar queries complexas para buscar documentos específicos
  3. Paginar resultados: Controlar quantidade de registros retornados (limit/skip)
  4. Ordenar resultados: Organizar documentos retornados por campos específicos

Como funciona internamente?

Quando o MONGODB FIND é executado, o sistema:

  1. Valida configuração: Verifica se as credenciais MongoDB foram fornecidas
  2. Estabelece conexão: Conecta ao servidor MongoDB usando as credenciais
  3. Seleciona coleção: Acessa a coleção especificada no banco de dados
  4. Processa query: Substitui variáveis e converte _id strings para ObjectId
  5. Aplica filtros: Executa a query com limit, skip e sort se especificados
  6. Retorna documentos: Busca todos os documentos que atendem aos critérios
  7. Armazena resultado: Salva documentos e contagem na variável especificada
  8. Fecha conexão: Encerra a conexão com MongoDB

Código interno (mongodb.executor.ts:109-140):

private async find(
  db: Db,
  collectionName: string,
  query: any,
  options: any,
  context: ExecutionContext,
): Promise<any> {
  const replacedQuery = this.replaceObjectVariables(query || {}, context.variables);
  const parsedQuery = this.parseMongoQuery(replacedQuery);

  const collection = db.collection(collectionName);
  let cursor = collection.find(parsedQuery);

  if (options.limit) {
    cursor = cursor.limit(parseInt(options.limit));
  }

  if (options.skip) {
    cursor = cursor.skip(parseInt(options.skip));
  }

  if (options.sort) {
    cursor = cursor.sort(options.sort);
  }

  const documents = await cursor.toArray();

  return {
    documents,
    count: documents.length,
  };
}

Quando você DEVE usar este Node?

Use MONGODB FIND sempre que precisar buscar múltiplos documentos de uma coleção MongoDB:

Casos de uso

  1. Listar produtos: "Buscar todos os produtos com estoque > 0"
  2. Buscar histórico: "Recuperar últimas 10 compras de um cliente"
  3. Relatórios: "Buscar todas as vendas do mês atual"
  4. Filtros complexos: "Buscar usuários ativos criados nos últimos 7 dias"

Quando NÃO usar MONGODB FIND

  • Buscar único documento: Use MONGODB FIND_ONE para melhor performance
  • Modificar ao buscar: Use MONGODB FIND_ONE_AND_UPDATE para atualizar
  • Agregações complexas: Use MONGODB AGGREGATE para pipelines

Parâmetros Detalhados

operation (string, obrigatório)

O que é: Define qual operação MongoDB será executada. Para buscar múltiplos documentos, use "find".

Padrão: Nenhum (obrigatório)

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Operation",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar Produtos",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {},
        "responseVariable": "produtos"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Resultado",
        "parameters": {
          "message": "Encontrados {{produtos.count}} produtos"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Execute o flow 2. Espere: "Encontrados X produtos" onde X é o número de documentos na coleção

config (object, obrigatório)

O que é: Objeto contendo as credenciais e configurações de conexão com o MongoDB.

Estrutura: - connectionString (string): String de conexão completa MongoDB - OU host, port, user, password: Configuração individual - database (string, obrigatório): Nome do banco de dados

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Config",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar com Config Completo",
        "operation": "find",
        "config": {
          "host": "localhost",
          "port": 27017,
          "database": "loja",
          "user": "admin",
          "password": "senha123"
        },
        "collection": "clientes",
        "query": {},
        "responseVariable": "clientes"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Confirmar Conexão",
        "parameters": {
          "message": "Conectado! {{clientes.count}} clientes encontrados"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Configure seu MongoDB local ou remoto 2. Execute o flow 3. Espere: "Conectado! X clientes encontrados"

collection (string, obrigatório)

O que é: Nome da coleção MongoDB onde a busca será realizada.

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Collection",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar na Coleção",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "ecommerce"
        },
        "collection": "orders",
        "query": {},
        "responseVariable": "pedidos"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Pedidos",
        "parameters": {
          "message": "Total de pedidos: {{pedidos.count}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Certifique-se que a coleção "orders" existe 2. Execute o flow 3. Espere: "Total de pedidos: X"

query (object, opcional)

O que é: Objeto de query MongoDB para filtrar documentos. Suporta todos os operadores MongoDB ($eq, $gt, $lt, $in, etc).

Padrão: {} (busca todos os documentos)

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Query",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar Produtos Ativos",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {
          "status": "ativo",
          "preco": { "$gte": 100 }
        },
        "responseVariable": "produtosAtivos"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Filtrados",
        "parameters": {
          "message": "Produtos ativos acima de R$100: {{produtosAtivos.count}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Popule a coleção "produtos" com alguns documentos 2. Execute o flow 3. Espere: "Produtos ativos acima de R$100: X"

limit (number, opcional)

O que é: Número máximo de documentos a serem retornados.

Padrão: Sem limite (retorna todos)

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Limit",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar Top 5",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {},
        "limit": 5,
        "responseVariable": "top5"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Limitado",
        "parameters": {
          "message": "Top 5 produtos: {{top5.count}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Execute o flow 2. Espere: "Top 5 produtos: 5" (ou menos se não houver 5 documentos)

skip (number, opcional)

O que é: Número de documentos a pular antes de começar a retornar resultados (útil para paginação).

Padrão: 0 (não pula nenhum)

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Skip",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Segunda Página",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {},
        "limit": 10,
        "skip": 10,
        "responseVariable": "pagina2"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Página 2",
        "parameters": {
          "message": "Página 2: {{pagina2.count}} produtos"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Execute o flow 2. Espere: "Página 2: X produtos" (produtos 11-20)

sort (object, opcional)

O que é: Objeto definindo campos e direção de ordenação (1 = ascendente, -1 = descendente).

Padrão: Sem ordenação

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Sort",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Ordenar por Preço",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {},
        "sort": { "preco": -1, "nome": 1 },
        "limit": 5,
        "responseVariable": "maisCaros"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Ordenados",
        "parameters": {
          "message": "5 produtos mais caros encontrados"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Execute o flow 2. Espere: "5 produtos mais caros encontrados"

responseVariable (string, opcional)

O que é: Nome da variável onde o resultado da busca será armazenado.

Padrão: Se não especificado, resultado não é armazenado

Flow completo para testar:

{
  "name": "Teste MongoDB Find - Response Variable",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar e Salvar",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "loja"
        },
        "collection": "produtos",
        "query": {},
        "responseVariable": "todosProdutos"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Usar Variável",
        "parameters": {
          "message": "Variável 'todosProdutos' contém {{todosProdutos.count}} documentos"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: 1. Execute o flow 2. Espere: "Variável 'todosProdutos' contém X documentos"

Parâmetros

Campo Tipo Obrigatório Descrição
operation string Sim Tipo de operação MongoDB ("find")
config object Sim Configuração de conexão MongoDB
collection string Sim Nome da coleção
query object Não Filtro de busca (padrão: {})
limit number Não Máximo de documentos a retornar
skip number Não Documentos a pular (padrão: 0)
sort object Não Ordenação dos resultados
responseVariable string Não Variável para armazenar resultado

Exemplo 1: Buscar Produtos em Estoque

Objetivo: Buscar todos os produtos com estoque disponível, ordenados por preço

JSON para Importar

{
  "name": "Buscar Produtos em Estoque",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Buscar Produtos",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "ecommerce"
        },
        "collection": "produtos",
        "query": {
          "estoque": { "$gt": 0 },
          "ativo": true
        },
        "sort": { "preco": 1 },
        "responseVariable": "produtosDisponiveis"
      }
    },
    {
      "id": "condition_1",
      "type": "condition",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Tem Produtos?",
        "conditions": [
          {
            "variable": "produtosDisponiveis.count",
            "operator": "greater_than",
            "value": "0",
            "targetNode": "message_success"
          }
        ],
        "defaultTarget": "message_empty"
      }
    },
    {
      "id": "message_success",
      "type": "message",
      "position": { "x": 700, "y": 50 },
      "data": {
        "label": "Sucesso",
        "parameters": {
          "message": "✅ Encontrados {{produtosDisponiveis.count}} produtos disponíveis!"
        }
      }
    },
    {
      "id": "message_empty",
      "type": "message",
      "position": { "x": 700, "y": 150 },
      "data": {
        "label": "Vazio",
        "parameters": {
          "message": "⚠️ Nenhum produto disponível no momento"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 900, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "condition_1" },
    { "source": "message_success", "target": "end_1" },
    { "source": "message_empty", "target": "end_1" }
  ]
}

Saída esperada:

Sistema: ✅ Encontrados 15 produtos disponíveis!

Exemplo 2: Paginação de Clientes

Objetivo: Implementar paginação para listar clientes de 10 em 10

JSON para Importar

{
  "name": "Paginação de Clientes",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "variable_1",
      "type": "variable",
      "position": { "x": 250, "y": 100 },
      "data": {
        "label": "Definir Página",
        "parameters": {
          "variables": [
            { "name": "pagina", "value": "1" },
            { "name": "porPagina", "value": "10" }
          ]
        }
      }
    },
    {
      "id": "calculator_1",
      "type": "calculator",
      "position": { "x": 400, "y": 100 },
      "data": {
        "label": "Calcular Skip",
        "operation": "multiply",
        "values": ["{{pagina}}", "{{porPagina}}"],
        "resultVariable": "skip"
      }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 550, "y": 100 },
      "data": {
        "label": "Buscar Página",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "crm"
        },
        "collection": "clientes",
        "query": {},
        "limit": "{{porPagina}}",
        "skip": "{{skip}}",
        "sort": { "nome": 1 },
        "responseVariable": "clientesPagina"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Mostrar Página",
        "parameters": {
          "message": "📄 Página {{pagina}}: {{clientesPagina.count}} clientes"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 850, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "variable_1" },
    { "source": "variable_1", "target": "calculator_1" },
    { "source": "calculator_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Saída esperada:

Sistema: 📄 Página 1: 10 clientes

Exemplo 3: Busca com Variáveis Dinâmicas

Objetivo: Buscar pedidos de um cliente específico usando variáveis do contexto

JSON para Importar

{
  "name": "Buscar Pedidos do Cliente",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "input_1",
      "type": "input",
      "position": { "x": 250, "y": 100 },
      "data": {
        "label": "ID do Cliente",
        "parameters": {
          "message": "Digite o ID do cliente:",
          "variable": "clienteId"
        }
      }
    },
    {
      "id": "mongodb_1",
      "type": "mongodb",
      "position": { "x": 400, "y": 100 },
      "data": {
        "label": "Buscar Pedidos",
        "operation": "find",
        "config": {
          "connectionString": "mongodb://localhost:27017",
          "database": "vendas"
        },
        "collection": "pedidos",
        "query": {
          "clienteId": "{{clienteId}}",
          "status": { "$ne": "cancelado" }
        },
        "sort": { "dataCriacao": -1 },
        "responseVariable": "pedidos"
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 550, "y": 100 },
      "data": {
        "label": "Mostrar Resultado",
        "parameters": {
          "message": "🛒 Cliente {{clienteId}}: {{pedidos.count}} pedidos ativos"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "input_1" },
    { "source": "input_1", "target": "mongodb_1" },
    { "source": "mongodb_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Saída esperada:

Sistema: Digite o ID do cliente:
Usuário: 507f1f77bcf86cd799439011
Sistema: 🛒 Cliente 507f1f77bcf86cd799439011: 3 pedidos ativos

Resposta do Node

{
  "documents": [
    {
      "_id": "507f1f77bcf86cd799439011",
      "nome": "Produto 1",
      "preco": 99.90,
      "estoque": 10
    },
    {
      "_id": "507f1f77bcf86cd799439012",
      "nome": "Produto 2",
      "preco": 149.90,
      "estoque": 5
    }
  ],
  "count": 2
}

Boas Práticas

✅ SIM:

  • Use limit para evitar buscar milhares de documentos de uma vez
  • Combine limit e skip para implementar paginação eficiente
  • Use índices no MongoDB para queries que serão executadas frequentemente
  • Filtre o máximo possível na query ao invés de processar depois
  • Use sort quando precisar de resultados ordenados
  • Armazene resultado em responseVariable para usar em nodes seguintes
  • Valide se count > 0 antes de processar documentos

❌ NÃO:

  • Não busque todos os documentos sem limit em coleções grandes
  • Não ignore a configuração de sort para resultados consistentes
  • Não esqueça de fechar conexões (o executor faz automaticamente)
  • Não use FIND quando precisa de apenas 1 documento (use FIND_ONE)
  • Não faça queries complexas sem índices apropriados

Dicas

💡 Dica 1: Para paginação, calcule skip = (pagina - 1) * limit antes de chamar o node

💡 Dica 2: ObjectIds são automaticamente convertidos quando você busca por _id como string

💡 Dica 3: Use { $exists: true } para buscar documentos que têm um campo específico

💡 Dica 4: Combine múltiplos filtros no objeto query para buscas mais precisas

💡 Dica 5: Para queries de texto completo, configure text indexes no MongoDB primeiro

Próximos Nodes

→ MONGODB FIND_ONE - Buscar um único documento → MONGODB INSERT - Inserir novos documentos → MONGODB UPDATE - Atualizar documentos existentes → MONGODB AGGREGATE - Executar pipelines de agregação