DEV Community: Gabriel_Silvestre

Introdução MCP

Gabriel_Silvestre — Thu, 27 Mar 2025 20:08:01 +0000

MCP

O que é?

O MCP é um protocolo de comunicação open-source que padroniza a forma pela qual aplicações provém contexto e disponibilizam ferramentas as LLMs. As aplicações por sua vez podem se conectar a N servidores, permitindo uma maior variedade de contexto e de capacidades.

Sua arquitetura segue o modelo client-server, sendo seus principais componentes:

MCP Hosts -> Aplicações que irão consumir o conteúdo e utilizar as ferramentas disponbilizadas via MCP (Ex: Claude Desktop, IDEs ou AI Tools);
MCP Clients -> Protocolo responsável pela manutenção e conexão 1:1 com o servidor (1 aplicação = N clients:N servers);
MCP Servers -> Programa leve que irá expor os recursos e capacidades do MCP previamente configurados;

Porque usar?

De acordo com a própria documentação: "O MCP ajuda a construir agentes e worflows complexos integrados com IA, uma vez que LLMs frequentemente precisam de uma forma de se conectar a diferentes fontes de dados para contexto e ferramentas para executar ações. E o que o MCP prove?"

Uma crescente lista de integrações "pré-construídas" que podem ser ligadas diretamente a sua aplicação;
Flexibilidade para alterar entre diferentes provedores de LLMs;
As melhores práticas para proteger seus dados, dentro da sua infraestrutura;

Como usar?

É possível construir clients e servers a partir de SDKs disponíveis para diferentes linguagens.

Comunicação Interna

Como explicado anteriormente, o MCP é constituído de 3 partes principais Hosts, Clients e Servers. Essas partes se comunicam através de diferentes tipos de mensagens, que por sua vez são enviadas e recebidas através do Protocol Layer e do Transport Layer.

Protocol layer

Camada responsável pelo recebimento e tratamento das mensagens trocadas entre client e server. Funciona de forma similar ao modelo request/response do HTTP.

Transport layer

Camada responsável pela real comunicação entre o client e o server. Utiliza JSON-RPC 2.0 para comunicação e segue seguinte especificação.

O MCP suporta 2 formas de comunicação nativamente, stdio que consiste em termos simples na leitura e execução do arquivo contendo a configuração do server pelo próprio client, útil para processamento local e para operações que exijam leitura e escrita. E também suporta nativamente a comunicação via HTTP/SSE para os casos onde o server ficará disponível de forma remota.

Além disso o MCP também permite a implementação de transports customizados.

Message types

O MCP possui 4 tipos de mensagens:

Request - Mensagem que espera uma resposta;

interface Request {
  method: string;
  params?: { ... };
}

Result - Mensagem de resposta a solicitação de Request;

interface Result {
  [key: string]: unknown;
}

Error - Indica que algo falhou;

interface Error {
  code: number;
  message: string;
  data?: unknown;
}

Notification - Mensagens de sentido único, não esperam resposta;

interface Notification {
  method: string;
  params?: { ... };
}

Resources

Os resources são um componente primitivo no MCP, sendo responsáveis pela exposição de dados ao client. Dados esses que podem ser textos, ou binários (que possam ser convertidos em base64) e serão lidos pelo usuário e/ou usados de contexto para LLMs.

Os resources foram criados para serem controlados pela aplicação (host), dessa forma diferentes aplicações lidam com os dados de formas diferentes, sendo assim é essencial que o server esteja apito a fornecer acesso a recursos de diferentes maneiras. Por exemplo (com a própria documentação):

O Claude Desktop exige que o usuário selecione explicitamente os recursos que serão consumidos pela LLM;
Outras aplicaçãoes podem escolher de forma pré-definida alguns recursos;
E por fim, pode ser que a própria LLM escolha quais recursos irá usar;

Entre as maneiras de acesso estão a forma direta, acessando um resource através de sua URI, e a forma dinâmica através de templates de URI. A URI por sua vez é a forma de identificação de um recurso, sendo estruturada da seguinte forma [protocol]://[host]/[path].

Exemplo (da própria documentação)

const server = new Server({
  name: "example-server",
  version: "1.0.0"
}, {
  capabilities: {
    resources: {}
  }
});

// List available resources
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "file:///logs/app.log",
        name: "Application Logs",
        mimeType: "text/plain"
      }
    ]
  };
});

// Read resource contents
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const uri = request.params.uri;

  if (uri === "file:///logs/app.log") {
    const logContents = await readLogFile();
    return {
      contents: [
        {
          uri,
          mimeType: "text/plain",
          text: logContents
        }
      ]
    };
  }

  throw new Error("Resource not found");
});

Prompts

Os prompts permitem definir no server templates de prompts reutilizáveis, bem como workflows que podem ser acionados pelo usuário, ou pela LLM, através do client. Um prompt pode aceitar argumentos dinâmicos, incluir contexto de resources, encadear múltiplas interações e guiar o usuário/LLM através de workflows.

Exemplo (da própria documentação)

import { Server } from "@modelcontextprotocol/sdk/server";
import {
  ListPromptsRequestSchema,
  GetPromptRequestSchema
} from "@modelcontextprotocol/sdk/types";

const PROMPTS = {
  "git-commit": {
    name: "git-commit",
    description: "Generate a Git commit message",
    arguments: [
      {
        name: "changes",
        description: "Git diff or description of changes",
        required: true
      }
    ]
  },
  "explain-code": {
    name: "explain-code",
    description: "Explain how code works",
    arguments: [
      {
        name: "code",
        description: "Code to explain",
        required: true
      },
      {
        name: "language",
        description: "Programming language",
        required: false
      }
    ]
  }
};

const server = new Server({
  name: "example-prompts-server",
  version: "1.0.0"
}, {
  capabilities: {
    prompts: {}
  }
});

// List available prompts
server.setRequestHandler(ListPromptsRequestSchema, async () => {
  return {
    prompts: Object.values(PROMPTS)
  };
});

// Get specific prompt
server.setRequestHandler(GetPromptRequestSchema, async (request) => {
  const prompt = PROMPTS[request.params.name];
  if (!prompt) {
    throw new Error(`Prompt not found: ${request.params.name}`);
  }

  if (request.params.name === "git-commit") {
    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Generate a concise but descriptive commit message for these changes:\n\n${request.params.arguments?.changes}`
          }
        }
      ]
    };
  }

  if (request.params.name === "explain-code") {
    const language = request.params.arguments?.language || "Unknown";
    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Explain how this ${language} code works:\n\n${request.params.arguments?.code}`
          }
        }
      ]
    };
  }

  throw new Error("Prompt implementation not found");
});

Tools

As tools permitem que as LLMs executem ações de forma quase 100% autonoma, apenas com a necessidade de um humano no fluxo por questão de design. Através das tools é possível realizar qualquer ação desde que ela retorne uma resposta.

Exemplo (da própria documentação)

const server = new Server({
  name: "example-server",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});

// Define available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [{
      name: "calculate_sum",
      description: "Add two numbers together",
      inputSchema: {
        type: "object",
        properties: {
          a: { type: "number" },
          b: { type: "number" }
        },
        required: ["a", "b"]
      }
    }]
  };
});

// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "calculate_sum") {
    const { a, b } = request.params.arguments;
    return {
      content: [
        {
          type: "text",
          text: String(a + b)
        }
      ]
    };
  }
  throw new Error("Tool not found");
});

Introdução as HOFs - .some() e .every()

Gabriel_Silvestre — Fri, 11 Nov 2022 00:56:54 +0000

Tabela de Conteúdo

some
every
Links Úteis

.some()

O que faz?

A HOF .some() irá verificar se ao menos um elemento do Array cumpre as condições estabelecidas.

[❌] Modifica o Array original

Sintaxe

O callback esperado deve retornar true ou false, para que então se possa fazer as verificações.

O .some() irá iterar sobre o Array até que um elemento cumpra a condição passada, retornando true. Caso nenhum elemento cumpra a condição, o .some() retornará false.

Array.some(callback);
Array.some((element, index, arr) => { });

Array.some((e) => {
  return e > 10; // verifica se ao menos um elemento é maior do que 10
});

const numbers = [10, 2, 32, 13, 21];

const haveSomeGreaterThanTen = numbers.some((number) => {
  return number > 10 // verifica se ao menos um número é maior do que 10
});

console.log(haveSomeGreaterThanTen); // true

Tradução - JavaScript -> Português

Podemos traduzir essa HOF com a seguinte expressão:

“Existe pelo menos um elemento que cumpre X condição?”

Voltar ao topo

.every()

O que faz?

A HOF .every() irá verificar se todos os elementos do Array cumprem as condições estabelecidas.

[❌] Modifica o Array original

Sintaxe

O callback esperado deve retornar true ou false, para que então se possa fazer as verificações.

O .every() irá iterar por todo o Array verificando se todos os elementos cumprem a condição passada, retornando true. Caso algum elemento não cumpra a condição, o .every() retornará false.

Array.every(callback);
Array.every((element, index, arr) => { });

Array.every((e) => {
  return e > 10; // verifica se todos os elemento são maiores do que 10
});

const cities = ["São Paulo", "Rio de Janeiro", "Curitiba"];

const areAllCitiesString = cities.every((city) => {
  return typeof city === 'string'; // verifica se todas as cidades são do tipo string
});

console.log(areAllCitiesString); // true

Tradução - JavaScript -> Português

Podemos traduzir essa HOF com a seguinte expressão:

“Todos os elementos cumprem X condição?”.

Voltar ao topo

Links Úteis

.some()

.every()

Voltar ao topo

Introdução as HOFs - .forEach() e .sort()

Gabriel_Silvestre — Wed, 09 Nov 2022 00:06:23 +0000

Tabela de Conteúdo

forEach
sort
Links Úteis

.forEach()

O que faz?

Itera sobre todos os elementos do array, possibilitando a manipulação desses valores, porém não retorna valor algum. Ou seja, podemos adicionar propriedades a objetos, adicionar eventListeners a elementos HTML e até mesmo trocar um valor por outro.

[✔] Modifica o Array original

Sintaxe

Essa HOF, assim como todas as outras, espera uma callback como parâmetro, sendo que essa callback, por sua vez, poderá receber até três parâmetros: o elemento; o índice; e o Array que foi iterado.

someArray.forEach(/* someCallback */);
someArray.forEach((element, index, arr) => {});

someArray.forEach((e, i) => {
  console.log(e); // imprime no console, um a um, todos os elementos do Array
});

const toys = ["trem", "car", "monster"];

toys.forEach((toy) => {
  toy.toUpperCase(); // coloca todos os brinquedos em caixa alta.
});

console.log(toys); // ["TREM", "CAR", "MONSTER"];

Tradução - JavaScript -> Português

Podemos traduzir essa HOF com a seguinte expressão:

“Para cada elemento, faça X coisa.”

Voltar ao topo

.sort()

O que faz?

Ordena o array de acordo com o critério estabelecido, por padrão essa função já possui um critério próprio, que é utilizado quando não passamos uma callback através dos parâmetros.

[✔] Modifica o Array original

Sintaxe

Essa HOF espera uma callback que recebe apenas dois parâmetros, sendo eles os valores a serem comparados na hora de ordenar o array. Diferente de outras HOFs, aqui não temos acesso ao índice ou ao array que estamos iterando.

O callback deve retornar um número positivo, negativo ou neutro (zero), a partir desse número o .sort irá alocar o elemento para frente ou para trás.

someArray.sort();
someArray.sort(/* someCallback */);
someArray.sort((a, b) => {});

someArray.sort((a, b) => {
  return a - b;
});

const numbers = [10, 2, 32, 13, 21];

numbers.sort(); // *O algorítimo de ordenação "padrão" do .sort() não é muito confiável
console.log(numbers); // [10, 13, 2, 21, 32]

numbers.sort((a, b) => a - b); // Ordena de forma crescente
console.log(numbers); // [2, 10, 13, 21, 32]

numbers.sort((a, b) => b - a); // Ordena de forma decrescente
console.log(numbers); // [32, 21, 13, 10, 2]

Tradução - JavaScript -> Português

Podemos traduzir essa HOF com a seguinte expressão:

“Ordene esse array de acordo com X condição.”.

Voltar ao topo

Links Úteis

.forEach()

.sort()

Voltar ao topo

MongoDB + Node

Gabriel_Silvestre — Thu, 03 Nov 2022 14:28:47 +0000

Tabela de Conteúdo

Mongoose
URI
Schemas
Models
Links Úteis

Mongoose

O que é?

O Mongoose é uma ferramenta de integração entre Node.js e MongoDB, tendo um funcionamento similar a ORMs, com a principal diferença de trabalhar com um DB NoSQL ao invés de um relacional, devido a isso ele é classificado como ODM (Object Document Mapping).

O que faz?

Como dito em sua definição, o Mongoose facilita a integração entre API e DB, para isso ele conta com diversos recursos que "rodam por baixo dos panos", porém um recurso explicito que vale a pena detalhar são os Schemas.

Os Schemas serão abordados mais a frente, mas o que vale a apena destacar é sua funcionamento, eles atuam de forma similar a uma "tipagem" para os Documentos do MongoDB, dessa forma podemos garantir um padrão nas Coleções.

Instalação

Para utilizarmos o Mongoose em nossos projetos primeiro devemos instalá-lo como uma dependência, após ter feito sua instalação tudo que precisamos fazer é conectá-lo a nossa aplicação.

Para conectar a aplicação ao MongoDB através do Mongoose devemos utilizar o método connect disponibilizado pela própria biblioteca, passando a URI como primeiro parâmetro e como segundo podemos passar algumas opções de conexão, essas que são optativas.

npm i mongoose

import { connect } from 'mongoose';

connect('mongodb://localhost:27017/my_db', { user: 'admin', password: 'admin' });

Voltar ao topo

URI

O que é?

É a sigla para Uniforme Resource Identifier, traduzindo, Identificador de Recurso Único.

Em palavras mais simples, é uma string que irá conter as informações necessárias para a conexão com o DB, esse que pode ser SQL ou NoSQL.

Sintaxe

A URI padrão do MongoDB consiste em: nome de usuário; dois pontos :; senha; arroba @; e então as informação de conexão, host e porta. Porém esse padrão não é o mais recomendado para se utilizar no Mongoose, afinal não seria nada inteligente deixar o usuário e a senha expostos em hard code.

No Mongoose podemos utilizar apenas os dados de conexão (host e porta) e o nome do banco de dados a ser conectado, assim passamos o usuário e senha através de um objeto no segundo parâmetro do método connect visto logo acima.

*Obs: As URIs sempre irão começar com mongodb://.

// URI padrão do MongoDB

connect('mongodb://<nome de usuário>:<senha>@<host>:<porta>/<nome do db>');
connect('mongodb://admin:admin@localhost:27017/my_db');

// URI do Mongoose com options

connect('mongodb://<host>:<porta>/<nome do db>', { user: '<nome de usuário>', password: '<senha>' });
connect('mongodb://localhost:27017/my_db', { user: 'admin', password: 'admin' });

**Obs: No exemplo acima estamos colocando o usuário e a senha também em "hard code" nas options do connect, porém isso é apenas a caráter de exemplificação, __o correto seria utilizar variáveis de ambiente_ para ambas as informações_

Voltar ao topo

Schemas

O que são?

São as estruturas básicas de um Documento MongoDB em nosso código TypeScript, dessa forma conseguimos mapear de forma eficiente todos os campos e por consequência melhorar a experiência de desenvolvimento.

O que fazem?

Os Schemas mapeiam os Documentos de uma coleção, facilitando a interação sobre os Documentos dentro do código da aplicação.

Sintaxe

Para definirmos um Schema utilizamos o construtor new Schema disponibilizado pelo próprio Mongoose, passando como Generic a interface que representa a estrutura do Documento.

import { Schema } from 'mongoose';

new Schema</* generic */>({
  /* nome do campo */: { type: /* tipo do campo */, required: /* true ou false */ },
  /* nome do campo */: { type: /* tipo do campo */, required: /* true ou false */ },
});

import { Schema } from 'mongoose';

interface IUser {
  username: string;
  email: string;
  password: string;
}

const userSchema = new Schema<IUser>({
  username: { type: String, required true },
  email: { type: String, required true },
  password: { type: String, required true },
});

Obs: Podemos passar outros dois Generics para o Schema, sendo eles a Model e os TInstanceMethods respectivamente, porém não iremos abordar eles aqui.

Voltar ao topo

Models

O que são?

No contexto do Mongoose as Models, assim como os Schemas, contém a estrutura básica de um Documento, mas além disso elas também nos disponibilizam métodos para que possamos interagir com os Documentos dentro de uma Coleção.

O que fazem?

Como dito em sua definição, as Models nos disponibilizam métodos para que possamos interagir com os Documentos, dessa forma conseguimos adicionar, atualizar, excluir e ler dados contidos nos Documentos de forma fácil.

Sintaxe

Para definir uma Model utilizamos a função model() disponibilizada pelo Mongoose, passando como Generic a interface que representa aquele documento, já como parâmetros passamos o nome da coleção e o Schema do Documento.

import { Schema, model } from 'mongoose';

interface /* Nome do documento */ {
  /* nome do campo */: /* tipo do campo */;
  /* nome do campo */: /* tipo do campo */;
  /* nome do campo */: /* tipo do campo */;
}

const /* nome do schema */ = new Schema</* interface */>({
  /* nome do campo */: { type: /* tipo do campo */, required: /* true ou false */ },
  /* nome do campo */: { type: /* tipo do campo */, required: /* true ou false */ },
});

const /* nome da model */ = model</* interface */>(/* nome da coleção */, /* schema */);

import { Schema, model } from 'mongoose';

interface IUser {
  username: string;
  email: string;
  password: string;
}

const userSchema = new Schema<IUser>({
  username: { type: String, required true },
  email: { type: String, required true },
  password: { type: String, required true },
});

const userModel = model<IUser>('users', userSchema);

*Obs: Não iremos abordar nenhum método das Models aqui, porém a sessão Links Úteis irá conter um link direcionado diretamente a essa parte da documentação.

Voltar ao topo

Links Úteis

Voltar ao topo

MongoDB - Updates Complexos

Gabriel_Silvestre — Wed, 03 Aug 2022 19:55:11 +0000

Tabela de Conteúdos

Modificadores de Atualizações em Arrays
Operador $push
Operador $pop
Operador pull
Operador $addToSet
Filtros em Arrays
Links Úteis

Modificadores de Atualizações em Arrays

O que são?

Modificadores de Atualizações em Arrays é uma tradução livre de Update Operator Modifiers, que nada mais são do que operadores que permitem a modificação do comportamento das atualizações em arrays internos de Documentos, possibilitando a ordenação, por exemplo.

Onde/Quando utilizar?

Como visto em sua definição logo acima, esses operadores interagem diretamente com arrays, logo devemos utilizá-los somente em interações onde os campos sejam desse tipo.

Lembrando que esses operadores, além de estarem restritos aos campos do tipo array, também só poderão ser utilizados em operações de atualização.

Quais são?

De acordo com a documentação oficial, existem quatro modificadores, esses que serão abordados logo abaixo.

São eles: $each; $position; $slice e $sort.

Sintaxe

Apesar de similares, cada Update Operator Modifiers possui uma peculiaridade em sua sintaxe, então iremos explicá-los individualmente.

$each

Função: permite a inserção de múltiplos valores em um campo do tipo array. (funciona somente com os operadores $push e $addToSet)
Sintaxe: deve ser declarado após o campo a sofrer modificação e recebe um array com os valores a serem inseridos.

{ <operador de atualização>: <campo>: { $each: [<valor 1>, <valor 2>, <valor 3>] } }

{ $push: tasks: { $each: ["study", "go to the gym", "read"] } }

voltar ao topo

$position

Função: permite a inserção de um, ou mais valores em uma posição específica do array. (funciona somente com o operador $push)
Sintaxe: é necessário o uso do $each previamente, após isso declaramos o $position e dizemos a partir de qual posição os novos valores serão inseridos.

{ $push: <campo>: { $each: [<valor 1>, <valor 2>, <valor 3>], $position: <index> } }

{ $push: tasks: { $each: ["study", "go to the gym", "read"], $position: 2 } }

voltar ao topo

$slice

Função: limita a inserção de novos valores. (funciona somente com o operador $push)
Sintaxe: é necessário o uso do $each previamente, após isso declaramos o $slice e definimos qual o número máximo de valores a serem adicionados.

{ $push: <campo>: { $each: [<valor 1>, <valor 2>, <valor 3>], $slice: <index> } }

{ $push: tasks: { $each: ["study", "go to the gym", "read"], $slice: 2 } }
# irá inserir somente o "study" e o "go to the gym"

voltar ao topo

$sort

Função: ordena todos os valores contidos no array, bem como os que serão adicionados. (funciona somente com o operador $push)
Sintaxe: é necessário o uso do $each previamente, após isso declaramos o $sort e definimos por qual campo será feita a ordenação, bem como o tipo de ordenação (crescente ou decrescente).

{ $push: <campo>: { $each: [<valor 1>, <valor 2>], $sort: { <campo>: <tipo de ordenação> } } }

{ $push: products: { $each: [{ name: "doll", qty: 5 }, { name:  "lego", qty: 2 }], $sort: { qty: 1 } } }
# no caso de não ser um objeto basta definir o tipo de ordenação diretamente => $sort: 1

voltar ao topo

Operador `$push`

O que é?

É um operador que lida diretamente com campos do tipo array, permitindo a adição de novos valores sem a necessidade de recriar o campo do zero.

Sintaxe

Há duas formas de se utilizar o operador $push, podemos adicionar apenas um item ao final do array, ou adicionar vários itens de uma única vez, além de conseguirmos alterar outros comportamentos, como ordenação automática.

Para o primeiros caso, basta invocarmos o $push, declararmos o campo a sofrer a adição e por fim definir o item a ser adicionado.

Já nos outros casos é obrigatório o uso do operador $each, que além de permitir a inserção de múltiplos valores, também abre a possibilidade de alterarmos mais comportamentos.

{ $push: { <campo>: <novo item> } }
{ $push: { <campo>: { $each: [<novos itens>], <outras configurações> } } }

{ $push: { products: { name: "computer", price: 2499.99 } } }
{ $push: { products: $each: [{ name: "computer", price: 2499.99 }, { name: "mouse", price: 499.99 }] } }

voltar ao topo

Operador `$pop`

O que é?

É um operador de deleção, ele poderá excluir o primeiro ou o último elemento de um array.

Sintaxe

Para deletarmos o primeiro ou o último item de um array basta invocarmos o método $pop, em seguida definimos o campo que contém o array a sofrer a deleção e por fim dizemos qual elemento a ser excluído (primeiro ou último).

{ $pop: { <campo>: <item a ser excluído> } }

{ $pop: { products: 1 } }
# 1 => exclui o último
# -1 => exclui o primeiro

voltar ao topo

Operador `$pull`

O que é?

É um operador que permite a deleção de itens em um campo do tipo array através de condições, dessa forma todos os itens que se encaixam nas condições definidas são excluídos.

Sintaxe

O primeiro passo é invocarmos o $pull, após isso definimos o campo a sofrer as deleções e por fim dizemos as condições a serem cumpridas para que um elemento seja deletado.

{ $pull: { <campo>: <query de deleção> } }  # query é equivalente a "conjunto de condições"

{ $pull: { products: { price: { $gt: 400.00 } } } }

voltar ao topo

Operador `$addToSet`

O que é?

Esse operador funciona de forma similar ao $push, porém além de adicionar novos valores a um campo do tipo array, o $addToSet também realiza uma verificação para evitar valores duplicados, ou seja, o novo valor somente será inserido se ele for único.

Vale ressaltar que esse o processo de validar Documentos duplicados é mais "sensível" ao erro, isso porque o operador irá considerar como duplicata apenas os Documentos que forem EXATAMENTE IGUAIS.

Sintaxe

Assim como seu funcionamento, sua sintaxe também é extremamente similar a do operador $push, o que significa que podemos adicionar um item, ou mais itens de uma única vez utilizando o $each, porém o $addToSet não aceita outras opções como o $sort.

Para adicionarmos um item basta invocarmos o operador $addToSet, seguido do campo a sofrer a adição e então definimos o novo valor a ser adicionado.

Já para adicionarmos múltiplos itens, invocamos o operador $addToSet, seguido do campo a sofrer a adição, depois declaramos o operador $each e por fim, dentro de um array, definimos os valores a serem adicionados.

{ $addToSet: { <campo>: <valor> } }
{ $addToSet: { <campo>: { $each: [<valor1>, <valor2>, <valor3>] } }

{ $addToSet: { email: gabriel@gabriel.com } }
{ $addToSet: { email: { $each: [gabriel@gabriel.com, daniela@daniela.com, fran@fran.com] } }

Obs: "Caso exista um valor duplicado dentro do array que estamos realizando a adição, o MongoDB executará a ação sem levantar nenhum erro, porém o valor duplicado não é adicionado, apenas mantêm-se o valor pré-existente".

voltar ao topo

Filtros em Arrays

O que são?

São formas pelas quais podemos selecionar um único valor dentro de um array de forma dinâmica, fazendo um paralelo com o JS, seria equivalente a HOF .find().

Sintaxe

A sintaxe desses filtros, apesar de simples, tem sua peculiaridade, isso porque ela funciona de forma similar a interpolação do mysql2 com node.

Utilizamos os filtros de array dentro operações de atualização, através do operador $[<identifier>] definimos um nome genérico que será usado como referência na interpolação. Agora para realmente definirmos o valor a ser buscado, utilizamos a opção arrayFilters, passando todas as referências que criamos anteriormente e atribuindo um valor a elas.

{ <operação de att>: { <campo>.$[<referência>]: <novo valor> } },
{ arrayFilters: [{ <referência>: <valor a ser buscado> }] }

{ $set: { tasks.$[t].title: "study Node" } },
{ arrayFilters: [{ t.title: "study React" }] }

# o item com o "title" study React vai ter seu valor trocado para study Node

# Por se tratar de um recurso mais complexo, irei exemplificar com o método de atualização completo
# A função continua sendo a mesma, trocar "study React" por "study Node"

db.user_tasks.updateOne(
  { _id: 1 },
  {
    $set: { tasks.$[T].title: "study Node" }
  },
  { arrayFilters: [{ T.title: "study React" }] }
)

voltar ao topo

Links Úteis

voltar ao topo

MongoDB - Updates Simples

Gabriel_Silvestre — Fri, 22 Jul 2022 14:01:27 +0000

Tabela de Conteúdo

updateOne()
updateMany()
Operador $set
Operador $mul
Operador $inc
Operadores $min e $max
Operador $currentDate
Operador $rename
Operador $unset
Links Úteis

updateOne()

O que é?

É um método do MongoDB que nos permite atualizar um único Documento dentro de uma coleção, mesmo que não passemos um filtro o método irá atualizar apenas um Documento.

Sintaxe

O updateOne() pode receber até três parâmetros, sendo os dois primeiros obrigatórios, são eles: um filtro; o "update" em si; e ao final opções para o update.

O filtro consiste em uma condição para que possamos achar o Documento a ser atualizado, nele podemos construir uma expressão de verificação utilizando qualquer um dos Operadores de Comparação/Lógicos vistos anteriormente.

Já o "update" são os campos com os novos dados a serem inseridos no Documento, nele podemos atualizar todos os campos ou apenas um. Enquanto as opções são configurações extras e opcionais que podemos fazer em nosso updateOne(), como definir as regras de comparação de strings, por exemplo.

db.<coleção>.updateOne(
  { <filtro> },
  { <update> },
  { <opções> }  # opcional
);

db.my-collection.updateOne(
  { name: "Gabriel" },
  { $set: { age: 22 } }  # o operador $set será abordado mais a frente
)

voltar ao topo

updateMany()

O que é?

É um método que permite a atualização de múltiplos Documentos de uma só vez e caso não utilizemos um filtro, todos os Documentos da Coleção serão atualizados.

Sintaxe

A sintaxe do updateMany() segue exatamente o mesmo padrão do updateOne(), recebendo até três parâmetros (filtro, update, opções) sendo os dois primeiros obrigatórios.

db.<coleção>.updateMany(
  { <filtro> },
  { <update> },
  { <opções> }  # opcional
);

db.my-collection.updateMany(
  { sale: true },
  { $mul: { price: Decimal128("0.8") } }  # o operador $mul será abordado mais a frente
)

voltar ao topo

Operador $set

O que é?

É um operador que irá alterar o valor de um, ou mais campos especificados, podendo alterar tantos os campos de 1º nível do Documento, assim como campos embedados.

Sintaxe

Por se tratar de um operador, seu uso deve ser feito dentro de um método que o aceite, no caso métodos de update.

Para utilizá-lo é muito simples, basta o declararmos e logo após definimos os campos e os seus novos valores.

{ $set: { <campo>: <valor>, <campo>: <valor> } }

{ $set: { color: "blue" } }

voltar ao topo

Operador $mul

O que é?

É um operador que irá MULtiplicar o valor do campo selecionado por um multiplicador especificado e como já é de se esperar, esse operador somente irá funcionar em campos do tipo numérico

Sintaxe

A sintaxe do $mul é tão simples quanto a do $set, com a única diferença de que algumas vezes iremos precisar realizar a conversão de tipos, como por exemplo de um inteiro para decimal.

Para realizar a multiplicação, tudo que precisamos fazer é declarar o campo a sofrer essa alteração e o multiplicador, se necessário, também precisamos fazer a conversão de tipos.

{ $mul: { <campo>: <multiplicador>, <campo>: <conversor>(<multiplicador>) } }

{ $mul: { price: 0.8, "sale.percentage": 0.2 } }

Obs: "Caso o campo no qual estamos tentando aplicar a multiplicação não exista, o MongoDB automaticamente o criará e atribuirá valor 0 a ele".

voltar ao topo

Operador $inc

O que é?

É um operador que incrementa ou decrementa, campos numéricos. O decremento é, de forma objetiva, um "incremento negativo", ou seja, utilizamos o $inc com um número negativo.

Sintaxe

Para realizarmos o incremento de um campo tudo que precisamos fazer é declarar o operador $inc e o campo a ser modificado, juntamente com o valor desejado.

{ $inc: { <campo>: <valor> } }

{ $inc: { qty: -5, order: 1 } }

Obs: "Caso o campo no qual estamos tentando aplicar o incremento não exista, o MongoDB automaticamente o criará e o atribuirá valor que estamos tentando aplicar a ele, mesmo que esse valor seja negativo".

voltar ao topo

Operadores $min e $max

O que são?

São operadores que realizam uma comparação para então aplicar a modificação desejada.

O $min irá aplicar a modificação apenas nos campos que possuírem um valor maior do que aquele especificado por nós após o operador, em palavras mais simples, o $min irá "arrastar" o valor do campo para baixo.

O $max irá aplicar a modificação apenas nos campos que possuírem um valor menor do que aquele especificado por nós após o operador, em palavras mais simples, o $max iras "arrastar" o valor do campo para cima.

Sintaxe

Apesar dos operadores possuírem comportamentos opostos, a sintaxe segue a mesma para ambos.

Primeiro declaramos o operador $min/$max, em seguida o campo que queremos modificar e por fim o novo valor que desejarmos.

{ $min: { <campo>: <valor> } }
{ $max: { <campo>: <valor> } }

{ $min: { stamina: 0 } }
{ $max: { maxMana: 4000 } }

Obs: "Caso o campo no qual estamos tentando aplicar a modificação não exista, o MongoDB automaticamente o criará e o atribuirá valor que estamos tentando aplicar a ele, mesmo que esse valor seja negativo".

voltar ao topo

Operador $currentDate

O que é?

É um operador que irá atribuir a data corrente ao campo especificado, essa data pode ter dois tipos: o Date, que é o padrão; ou o timestamps.

Sintaxe

Para utilizarmos o operador $currentDate tudo o que precisamos fazer é declará-lo, dizer qual campo irá recebe-lo e por fim passar true como valor do campo.

Porém se quisermos utilizar timestamp como formato precisamos utilizar o operador $type, especificando o formato timestamp através de uma string.

{ $currentDate: { <campo>: <formato> } }

{ $currentDate: { lastUpdate: true, canceled: { $type: "timestamp" } } }

Obs: "Caso o campo no qual estamos tentando aplicar a modificação de data não exista, o MongoDB automaticamente o criará e o atribuirá a data atual a ele no formato especificado".

voltar ao topo

Operador $rename

O que é?

É um operador que permite a troca da nomenclatura dos campos de um ou mais Documentos.

Sintaxe

A sintaxe geral segue a mesma estrutura dos operadores vistos anteriormente, o invocamos, dizemos o campo a sofrer a modificação e por fim especificamos um novo valor. A única diferença é que o $rename não irá alterar o valor do campo, mas o campo em si.

Sintaxe

Primeiro invocamos o operador $rename, em seguida declaramos o campo a ser renomeado e por fim dizemos qual deverá ser o novo nome.

{ $rename: { <campo>: <novo nome> } }

{ $rename: { promotion: "sales" } }

Obs: "Caso o campo que estamos tentando renomear não exista, o MongoDB não irá gerar um erro, apenas não realizará nenhuma modificação".

voltar ao topo

Operador $unset

O que é?

É um operador de deleção de campos, sempre que desejarmos excluir algum campo de um ou mais documentos, utilizamos o $unset.

Sintaxe

Invocamos o operador $unset, seguido do campo a ser deletado e por fim passamos uma string vazia como valor.

Vale reforçar que o valor pode ser literalmente qualquer coisa, porém a documentação oficial exemplifica com uma string vazia.

{ $unset: { <campo>: "" } }

{ $unset: { uselessCamp: "" } }
{ $unset: { uselessCamp: "trem" } }  # irá deletar o campo uselessCamp igual

Obs: "Caso o campo que estamos tentando deletar não exista, o MongoDB não irá gerar um erro, apenas não realizará nenhuma modificação".

voltar ao topo

Links Úteis

voltar ao topo

MongoDB - Consulta em Arrays

Gabriel_Silvestre — Mon, 18 Jul 2022 17:38:00 +0000

Tabela de Conteúdos

Busca em Arrays
Busca de Avaliação
Links Úteis

Busca em Arrays

O que é?

É a possibilidade de buscar informações dentro de arrays que estão dentro de Documentos, podemos fazer isso através dos Operadores Lógicos e de Comparação, porém existem operadores específicos para tal tarefa, esses que serão abordados logo abaixo.

Quais são?

De acordo com a documentação oficial existem três operadores que realizam buscas dentro de arrays, são eles: $all, $elemMatch e $size. Cada um deles será explicado melhor logo abaixo.

Sintaxe

Por se tratar de um operador, a sintaxe básica segue a mesma dos outros operadores, com a única diferença que sempre estaremos buscando um valor dentro de um array, logo todo o campo que desejarmos filtrar deve ser um array.

Dentro de um parâmetro de filtro declaramos o operador e quais valores ele deve buscar, sendo que cada operador irá aceitar o valor em um formato diferente.

{ <campo>: { <operador>: <valor> } }

`$all`

Função: retorna todos os Documentos em que o campo pesquisado seja um array com todos os valores definidos no filtro, independente se houver mais elementos ou a ordem estiver diferente.

{ foods: { $all: ["burger", "fries"] } }

# retorna todos os Documentos que possuam burger e fries no campo "foods"

Voltar ao top

`$elemMatch`

Função: retorna todos os Documentos em que o campo pesquisado seja um array com ao menos um valor que satisfaça a condição estabelecida no filtro.

{ sales: { $elemMatch: { $gt: 40, $lt: 80 }} }  

# retorna todos os Documentos que possuam ao menos um valor maior que 40 e menor que 80 no campo "sales"

Voltar ao top

`$size`

Função: retorna todos os Documentos em que o campo pesquisado seja um array com o tamanho especificado.

{ tags: { $size: 4 } }  

# retorna todos os Documentos que possuam exatamente 4 elementos dentro do campo "tags"

# não é possível buscar utilizar o $size junto de Operadores de Comparação,
# por exemplo: um array com MAIS DE dois elementos

Voltar ao top

Busca de Avaliação

O que é?

Busca de Avaliação é a tradução livre de Evaluation Query Operators, que de forma simplificada, consiste em operadores que irão "avaliar" um campo específico de acordo com as regras exigidas.

Essa avaliação pode ser interna entre dois, ou mais campos, de um mesmo Documento, ou externa como os operadores vistos anteriormente.

Quais são?

Existem ao todo seis Evaluation Query Operators, porém aqui iremos abordar somente os operadores: expr, $regex e $mod.

Sintaxe

Cada Evaluation Query Operators possui uma sintaxe muito distinta, então iremos explicar a sintaxe de cada um individualmente.

`$expr`

Função: permite a comparação entre dois campos de um mesmo Documento, essa comparação é construída a partir de outros operadores, como os de comparação ou lógicos.
Sintaxe: declaramos o operador $expr, em seguida criamos a validação necessária e por fim dizemos os campos a serem comparados através de um array, esses campos devem receber um $ assim como os operadores.

{ $expr: { $gt: ["$credit", "$debit"] } }

# retorna todos os Documentos em que o campo "credit" seja maior que "debit"

Voltar ao top

`$regex`

Função: permite a pesquisa de textos através de REGEX.
Sintaxe: declaramos o campo que desejamos realizar a busca, em seguida utilizamos o operador $regex com a REGEX a ser verificada.

{ title: { $regex: /Lord/i } }

# retorna todos os Documentos em que o campo "title" seja válido pela REGEX /lord/i

Voltar ao top

`$mod`

Função: retorna todos os Documentos em que o campo selecionado dividido pelo valor declarado, resulte no módulo esperado.
Sintaxe: declaramos o campo que desejamos verificar, em seguida utilizamos o operador $mod e através de um array declaramos o divisor e o módulo esperado, respectivamente.

{ qty: { $mod: [2, 0] } }

# retorna todos os Documentos em que o campo "qty" dividido por 2, tenha um módulo igual a 0

Voltar ao top

Links Úteis

MondoDB - Filter Operators

Gabriel_Silvestre — Wed, 29 Jun 2022 20:07:00 +0000

Tabela de Conteúdos

Operadores de Comparação
Operadores Lógicos
Método sort()
Removendo Documentos
Links Úteis

Operadores de Comparação

O que são?

São operadores utilizados para a comparação de valores, sendo normalmente aplicados a métodos para leitura, atualização ou exclusão de Documentos.

Sintaxe

Todos os Operadores de Comparação seguem a mesma estrutura base, indicamos o campo que queremos verificar, seguido do operador junto do valor.

{ <campo>: { <operador>: <valor> } }

Obs: Lembrando que esses operadores devem ser aplicados a métodos que suportem a aplicação de filtros, como o find(), countDocuments() ou o update().

Voltar ao top

Quais são?

`$lt`

Tradução: Less than, em português Menor que.

O operador irá buscar todos os valores Menores que ...

{ age: { $lt: 20 } }  # busca todos os Documentos com a propriedade "age" menor que 20

Voltar ao top

`$lte`

Tradução: Less than or Equal, em português Menor ou Igual a.

O operador irá buscar todos os valores Menores ou Iguais a ...

{ price: { $lte: 29 } }  # busca todos os Documentos com a propriedade "price" menor ou igual a 29

Voltar ao top

`$gt`

Tradução: Greater than, em português Maior que.

O operador irá buscar todos os valores Maiores que ...

{ age: { $gt: 18 } }  # busca todos os Documentos com a propriedade "age" maior que 18

Voltar ao top

`$gte`

Tradução: Greater than or Equal, em português Maior ou Igual a.

O operador irá buscar todos os valores Maiores ou Iguais a ...

{ mana: { $gte: 400 } }  # busca todos os Documentos com a propriedade "mana" maior ou igual a 400

Voltar ao top

`$eq`

Tradução: Equal, em português Igual a.

O operador irá buscar todos os valores Iguais a ...

{ _id: { $eq: 2 } }  # busca todos os Documentos com a propriedade "_id" igual a 2

{ _id: 2 }  # podemos omitir o operador $eq de nosso filtro e o comportamento será o mesmo

Voltar ao top

`$ne`

Tradução: Not Equal, em português Diferentes de.

O operador irá buscar todos os valores Diferentes de ...

{ class: { $ne: "Fighter" } }  # busca todos os Documentos com a propriedade "class" diferente de Fighter

Voltar ao top

`$in`

Tradução: In, em português Dentro de.

O operador irá buscar todos os valores Dentro de ...

{ country: { $in: ["BR", "USA", "CAN"] } }  # busca todos os Documentos com a propriedade "country" dentro das seguintes opções BR, USA, CAN

Voltar ao top

`$nin`

Tradução: Not In, em português Fora de.

O operador irá buscar todos os valores Fora de ...

{ country: { $nin: ["BR", "USA", "CAN"] } }  # busca todos os Documentos com a propriedade "country" fora das seguintes opções BR, USA, CAN

Voltar ao top

Operadores Lógicos

O que são?

Assim como em linguagens de programação, os Operadores Lógicos do MongoDB realizam "inferências lógicas", exemplificando, podemos verificar se a condição X E a condição Y são verdadeiras, assim como também podemos verificar se ao menos uma delas é verdadeira através do OU.

Sintaxe

Assim como os Operadores de Comparação, os lógicos também devem ser utilizados somente nos métodos que aceitam algum tipo de filtro como parâmetro.

Há duas possíveis estruturas para os Operadores Lógicos, podemos ter uma estrutura simples, no qual não é possível concatenar verificações e estruturas mais complexas que suportam a concatenação de verificações.

O único Operador Lógico que não suporta essa concatenação é o $not e sua estrutura consiste em utilizar o operador depois do campo e antes da verificação.

# Sintaxe para o operador $not
{ <campo>: { <operador lógico>: { <operador de comparação>: <valor> } } }

Já o restante dos Operadores Lógicos suporta a concatenação e sua estrutura é ligeiramente diferente, definimos o Operador a frente de tudo e dentro de um Array adicionamos nossas verificações

# Sintaxe para os o restante dos operadores
{ <operador lógico>: [{ <campo>: { <comparador>: <valor> } }, { <campo>: { <comparador>: <valor> } }] }

Quais são?

`$not`

Tradução: Not, em português Não é.

O operador irá buscar todos os valores que Não são ... / Não possuem ...

{ price: { $not: { $gt: 19.99 } } }  # busca todos os Documentos com a propriedade "price" NÃO maior que 19.99

# também busca todos os Documentos que NÃO possuem a propriedade "price"

Voltar ao top

`$or`

Tradução: Or, em português Ou.

O operador irá buscar todos os valores que Ou é isso, Ou é aquilo ...

{ $or: [{ promo: true }, { price: { $lt: 19.99 } }] }
# busca todos os documentos que a propriedade "promo" seja verdadeira,
# OU que tenham a propriedade "price" menor que 19.99

Voltar ao top

`$nor`

Tradução: Or not, em português Ou não.

O operador irá buscar todos os valores que Ou Não é isso, Ou Não é aquilo ...

{ $nor: [{ promo: true }, { price: { $lt: 19.99 } }] }
# busca todos os documentos que a propriedade "promo" NÃO seja verdadeira,
# OU que propriedade "price" NÃO seja menor que 19.99

Voltar ao top

`$and`

Tradução: AND, em português E.

O operador irá buscar todos os valores que são isso E aquilo ...

{ $and: [{ promo: true }, { price: { $lt: 19.99 } }] }
# busca todos os documentos que a propriedade "promo" seja verdadeira,
# E que tenham a propriedade "price" menor que 19.99

Voltar ao top

`sort()`

O que é?

É um método utilizado para ordenar os resultados de uma busca, essa ordenação pode ser numérica, alfabética, crescente ou decrescente.

Sintaxe

O método sort() deve ser utilizado após uma busca, ou seja, deve ser invocado logo após o método find().

O sort() aceita "infinitos" parâmetros, esses que devem vir no formato chave:valor, onde a chave indica o campo a ser utilizado na ordenação e o valor diz se a ordenação deverá ser crescente ou decrescente.

db.my-collection.find().sort({ <campo>: <tipo de ordenação> })

db.my-collection.find().sort({ price: 1 })  # 1 indica ordenação crescente
db.my-collection.find().sort({ price: -1 })  # -1 indica ordenação decrescente

db.my-collection.find().sort({ price: 1 }, { title: 1 })  # podemos ordenar por mais de um campo

Voltar ao top

Removendo Documentos

O que é?

É a forma como podemos deletar um, ou mais, Documentos de nossa Coleção.

Sintaxe

Temos duas formas de deletarmos Documentos de nossas Coleções, podemos excluir apenas um, ou vários de uma vez. Para ambos os casos a sintaxe é basicamente a mesma, o que irá mudar será apenas o método.

Para removermos um documento iremos invocar o método de deleção desejado, passando para ele um objeto como parâmetro, esse objeto poderá conter apenas uma condição simples, bem como condições mais complexas.

Obs: Também podemos realizar deleções sem definir um filtro específico, porém isso não é recomendado. (equivalente ao DELETE sem WHERE).

# para deletar apenas um documento utilizamos o deleteOne()

db.my-collection.deleteOne({})  # exclui apenas o primeiro Documento da Coleção
db.my-collection.deleteOne({ _id: 4 })

# para deletar diversos documentos de uma única vez, utilizamos o deleteMany()

db.my-collection.deleteMany({})  # irá deletar TODOS os Documentos da Coleção
db.my-collection.deleteMany({ qty: 0 })

Voltar ao top

Links Úteis

Voltar ao top

Introdução ao MongoDB

Gabriel_Silvestre — Mon, 20 Jun 2022 20:54:14 +0000

Tabela de Conteúdos

Estrutura do MongoDB
Bancos de Dados
Coleções
Documentos
Regras
InsertOne
InsertMany
Find
Operadores de Comparação
Links Úteis

Estrutura do MongoDB

Classe

O que é?

Apesar de serem englobados dentro de um mesmo escopo, os banco de dados NoSQL possuem diferentes tipos de armazenamento, em outras palavras, são de classes diferentes.

Document

Não iremos abordar todos os tipo de classe NoSQL aqui, iremos focar apenas na classe do MongoDB, Document.

A classe Document é a mais flexível dentre todas, seu formato de armazenamento é similar ao JSON, no MongoDB por exemplo, esse formato é chamado de BSON. De forma prática iremos armazenar os dados no formato de um "Objeto JavaScript", onde temos chave:valor, sendo que cada valor poderá conter outro objeto e assim sucessivamente.

Qual é?

A estrutura "interna" do MongoDB consiste em três partes, que serão explicadas logo abaixo, são elas: os Bancos de Dados, as Coleções e os Documentos.

Voltar ao top

Bancos de Dados

O que são?

Assim como em DB relacionais, os NoSQL podem possuir mais de um banco de dados cada, ou seja, é onde iremos armazenar as Coleções.

A maior diferença entre Bancos de Dados SQL e MongoDB (além do funcionamento interno) é a capacidade de se "auto criar" um novo Banco de Dados conforme a necessidade, ou seja, ao realizarmos uma operação em um Banco de Dados que ainda não existe, ele será criado de forma automática para nós, incluindo a operação que acabamos de fazer.

Voltar ao top

Coleções

O que são?

Fazendo um paralelo aos DB relacionais, as Coleções seriam equivalentes as Tabelas, que por sua vez seriam responsáveis por armazenar Documentos.

Voltar ao top

Documentos

O que são?

São equivalentes as entidades de um DB relacional, o que seria armazenado em uma linha da Tabela, irá ser armazenado como um objeto BSON dentro da Coleção.

Voltar ao top

Regras

O que são?

São restrições aplicadas a criação de Tables/Collections e inserção de dados através de Entity/Document.

SQL x MongoDB

Diferente de Tabelas e Entidades dos bancos de dados relacionais, as Coleções e Documentos de um banco de dados como o MongoDB podem ser completamente livres de regras, logo podemos ter dentro de uma mesma Coleção, Documentos com estruturas extremamente diferentes.

Apesar de isso ser possível e não gerar nenhum tipo de erro interno no DB, ainda temos a opção de "regrar" a criação de Documentos, sendo que essa regra deverá ocorrer em nível de Documento e não de Coleção.

Obs: Podemos aplicar regras em níveis de Coleção, porém caso já existam Documentos salvos, as regras podem impactá-los.

Regrando

Para adicionar as restrições na criação de um novo documento utilizamos o Schema Validation, recurso nativo do MongoDB, esse que não será abordado aqui, porém a documentação é bem didática em sua explicação.

Documentação - Schema Validation

Voltar ao top

`InsertOne()`

O que é?

É um comando do MongoDB que permite a inserção de um novo Documento a uma Coleção, essa que não precisa existir previamente.

Sintaxe

A sintaxe desse comando é, de certa forma, similar a do JavaScript, mas não se engane, é um comando para ser utilizado no mongo shell (mongosh).

Para executarmos esse comando precisamos ter previamente selecionado um banco de dados do MongoDB, após isso utilizamos a palavra reservada db, seguida da Coleção a receber o Documento e por fim o comando insertOne() recebendo por parâmetro, em forma de Objeto (JSON), as informações do Documento.

use <nome do banco de dados>
db.<nome da coleção>.insertOne({ });

use my-database
db.user.insertOne({ "name": "Gabriel", "age": 21 });

Voltar ao top

`InsertMany()`

O que é?

É um comando para a inserção de múltiplos valores dentro de uma Coleção, sendo que por padrão esses valores são inseridos de forma ordenada, porém podemos alterar esse comportamento.

Quando inseridos de forma ordenada, os Documentos podem sofrer uma "parada" na inserção caso ocorra algum erro, dessa forma apenas os Documentos antes do erro ter ocorrido serão inseridos. Porém caso optemos por inserir de forma não ordenada, todos os Documentos que não gerarem erro serão inseridos, por mais que outros gerem.

Sintaxe

Esse comando é extremamente similar ao insertOne, com a única diferença que iremos passar nossos Documentos dentro de um Array.

use <nome do banco de dados>
db.<nome da coleção>.insertMany([{ }, { }]);

use my-database
db.user.insertMany([{ "name": "Gabriel", "age": 21 }, { "name": "Daniela", "age": 23 }]);

Voltar ao top

`Find()`

O que é?

É um comando para a pesquisa de Documentos, onde podemos aplicar filtros de busca, bem como definir o formato de retorno da busca.

Sintaxe

Assim como os comandos vistos anteriormente, esse também irá seguir uma sintaxe similar, utilizando o db seguido da Coleção e indicando o comando find() ao final, porém o comando em si pode receber até dois argumentos, sendo ambos em formato de JSON.

O primeiro argumento é um filtro de busca no qual pesquisamos os Documentos através de seus campos, para isso utilizamos um JSON, definindo a chave a ser usada no filtro e qual valor ela deverá ter.

O segundo argumento é uma "modelagem" do Documento encontrado, dessa forma podemos definir os campos que queremos que sejam retornados, ou ocultados, da busca realizada. Para definir que um campo deve ser retornado usamos seu nome seguido do número 1 e caso desejarmos ocultá-lo usamos o número 0.

use <nome do banco de dados>

db.<nome da coleção>.find();  # retorna todos os Documentos
db.<nome da coleção>.find({ });  # define apenas o "filtro"
db.<nome da coleção>.find({ }, { });  # define o "filtro" e o formato do retorno

use my-database

db.my-database.find();
db.my-database.find({ });
db.my-database.find({ }, { });

Voltar ao top

Operadores de Comparação

O que são?

Como o nome diz, são operadores que realizam comparações entre os valores, normalmente utilizados para a criação de filtros.

Sintaxe

Os Operadores de Comparação do MongoDB nada mais são do que "chaves reservadas", logo tudo que precisamos fazer é passar a chave para a comparação desejada e o valor a ser comparado.

A lista de chaves de comparação do MongoDB é relativamente extensa, então ela não será abordada aqui, porém recomendo a consulta da documentação.

Por fim para aplicarmos os Operadores de Comparação, basta escolhermos uma ação a ser feita como, pesquisa find por exemplo, e dentro do parâmetro de filtro utilizar os operadores.

use <nome do banco de dados>

db.<nome da coleção>.find({ });

use my-database

db.my-database.find({ age: { $gt: 18 } });  # busca todos os Documentos que tenha a idade maior que 18

Voltar ao top

Links Úteis

Voltar ao top

Introdução ao SOLID - Princípios L e I

Gabriel_Silvestre — Mon, 20 Jun 2022 20:50:31 +0000

Tabela de Conteúdos

Liskov Substitution Principle
Interface Segregation Principle
Links Úteis

Liskov Substitution Principle

Recomendação

O Princípio de Substituição de Liskov diz que devemos poder utilizar uma sub-classe, no lugar de uma super-classe. Na prática isso ocorre através da implementação de Interfaces, ou através da herança de classes, dessa forma toda a sub-classe que implementa determinada interface, ou herda de determinada super-classe, deve poder ser usada como substituto.

Exemplo

A forma mais fácil de se entender o Princípio de Substituição de Liskov é através de classes que fazem a conexão com o banco de dados, dessa forma podemos ter diversas classes, responsáveis por diversos bancos, podendo se substituírem sem a geração de efeitos colaterais (bugs).

Pensando no contexto acima, vamos exemplificar a criação de um usuário em dois DB diferentes, o MySQL e o MongoDB. Para isso iremos criar duas classes que implementam uma mesma Interface e utilizá-las da mesma forma.

interface IUserRepository {
  create(name: string, age: number): Promise<void>;
}

import mysql from 'mysql2/promise';  // Esse pacote foi utilizado apenas como exemplo

class UserRepositoryMySQL implements IUserRepository {
  constructor() {
    this.mysql = mysql.createPool({
      /* configuração da conexão */
    });
  }

    async create(name: string, age: number): Promise<void> {
      await this.mysql.execute(
        'INSERT INTO users (name, age) VALUES (?, ?);',
        [name, age]
      )
    }
  }

import { User } from 'mongooseModels';  // pasta "fictícia"que armazena as Models do Mongoose

class UserRepositoryMongo implements IUserRepository {
  constructor() {
    this.userModel = new User();
  }

  async create(name: string, age: number): Promise<void> {
    await this.userMode.create({ name, age });
  }
}

import { IUserRepository } from 'IUserRepository';

class CreateUSerService {
  constructor(private userRepository: IUserRepository) {}

  async execute(name: string, age: number) {
    this.userRepository.create(name, age);
  }
}

import { Request, Response, NextFunction } from 'express';

import { UserRepositoryMySQL } from 'UserRepositoryMySQL';
import { UserRepositoryMongo } from 'UserRepositoryMongo';

import { CreateUserService } from 'CreateUserService';

const userRepositoryMySQL = new UserRepositoryMySQL();
const userRepositoryMongo = new UserRepositoryMongo();

/* ---------- Criando usuário no MySQL ---------- */
const createUserService = new CreateUserService(userRepositoryMySQL);
/* ---------- ----------------------- ---------- */

/* ---------- Criando usuário no MongoDB ---------- */
const createUserService = new CreateUserService(userRepositoryMongo);
/* ---------- ------------------------- ---------- */

const createUserRoute = async (req: Request, res: Response, next: NextFunction) => {
  const { name, age } = req.body;

  try {
    await createUserService.execute(name, age);
    res.status(200).end();
  } catch {
    res.status(500).json({ message: 'Internal server error' });
  }
}

No exemplo acima criamos duas classes que lidam com DB diferentes, porém podemos utilizar qualquer uma das duas em nosso serviço de criação de usuário CreateUSerService, isso porque o serviço espera a Interface IUserRepository e como nossas classes implementam essa Interface podem ser usadas como substitutas.

Voltar ao top

Interface Segregation Principle

Recomendação

O Princípio de Segregação de Interfaces recomenda que separemos nossas Interfaces em "blocos mínimos", em outras palavras, as criemos altamente especializadas e caso surja a necessidade, podemos criar uma Interface mais completa estendendo as mais específicas.

Exemplo

O Princípio de Segregação de Interfaces é, na minha opinião, o mais simples de se entender o conceito teórico, porém o mais difícil de se aplicar em um caso real.

Nosso exemplo será uma classe de serviço de uma API, ele deverá obrigatoriamente possuir o método execute para executar sua tarefa e opcionalmente poderá possuir métodos de validação, como por exemplo: validar se um email já está em uso.

// Iremos utilizar generics para "tipar" o input <T> e o output <O> posteriormente

interface IServiceExecute<T, O> {
  execute(T): Promise<O>;
}

interface IServiceValidUnique<T> {
  isUnique(T): Promise<boolean>;
}

interface IRequest {
  username: string;
  email: string;
  password: string;
}

interface ICreatedUser extends IRequest {
  id: string;
}

type UniqueUser = Pick<IRequest, 'email'>

class RegisterUserService implements IServiceExecute<IRequest | null, ICreateUser>, IServiceValidUnique<UniqueUser> {
  constructor(private repository: IRepository) {}

  async isUnique({ email }: UniqueUSer): Promise<boolean> {
    const emailAlreadyInUse = await this.repository.find(email);

    if (emailAlreadyInUse) {
      return false;
    }

    return true;
  }

  async execute({ username, email, password }: IRequest): Promise<ICreatedUser> {
    const isUnique = await this.isUnique({ email });

    if (!isUnique) {
      return null;
    }

    const newUSer = await this.repository.create({ username, email, password });
    return newUser;
  }
}

No exemplo acima estamos aplicando duas Interfaces em uma única classe, isso porque cada Interface é responsável apenas por uma funcionalidade, dessa forma se precisarmos construir um serviço que não precise de validação, podemos apenas implementar a IServiceExecute.

Obs: As Interfaces criadas junto da classe são um "complemento" as outras, isso porque optei por utilizar Generics na criação das Interfaces de serviço, logo é necessário inferir seu tipo posteriormente através de tipos primitivos, types ou interfaces.

Voltar ao top

Links Úteis

Voltar ao top

Introdução ao SOLID - Princípios S O D

Gabriel_Silvestre — Fri, 20 May 2022 21:56:47 +0000

Tabela de Conteúdo

SOLID
Single Responsibility Principle
Open/Closed Principle
Dependency Inversion Principle
Repositório
Links Úteis

SOLID

O que é?

SOLID, na programação, refere-se a cinco princípios que focam na escrita de um código limpo, legível e de fácil manutenção.

Princípios

Single responsibility principle
Open/Close principle
Liskov substitution principle
Interface segregation principle
Dependency inversion principle

Aviso

O SOLID propõe PRINCÍPIOS a serem seguidos para o desenvolvimento de um código mais limpo, porém esses princípios não são absolutos e podem muito bem ser ignorados ou adaptados ao nosso contexto.

Em outras palavras, o SOLID nos da boas recomendações a serem seguidas, mas não passa disso, RECOMENDAÇÕES.

"Regra nenhuma, princípio nenhum e caso especial nenhum deve piorar a legibilidade ou a manutenibilidade do seu código."

Voltar ao topo

Single Responsibility Principle

Recomendação

O princípio da responsabilidade única recomenda que cada função ou classe realize uma única ação, dessa forma teremos nosso código divido em pequenos blocos altamente "especializados".

Exemplo

Imagine que precisemos efetuar o pagamento de uma conta em outra moeda, para isso vamos precisar converter o valor para Real, acessar nossa carteira (banco de dados), recuperarmos nosso saldo e se nosso saldo for suficiente, pagar a conta.

const EXCHANGE = {
  USD: 4.6,
  EUR: 5,
  CAD: 3.7,
};

type ICurrency = keyof typeof EXCHANGE;

const convertValue = (value: number, currency: ICurrency) => {
  return Math.floor(value * EXCHANGE[currency]);
};

const getBalance = async () => {
  const query = `
    SELECT amount FROM user.wallet;
  `;

  const [{ amount }] = await mysql.execute(query);

  return amount;
};

const isEnough = (personalBalance: number, totalAmount: number) => {
  return personalBalance > totalAmount;
};

const payBill = async (billValue: number, billCurrency: ICurrency) => {
  const myBalance = await getBalance();
  const convertedValue = convertValue(billValue, billCurrency);

  if (isEnough(myBalance, convertedValue)) {
    return `Conta paga | saldo anterior ${myBalance} | saldo atual ${
      myBalance - convertedValue
    }`;
  }

  return `Saldo insuficiente | saldo anterior ${myBalance} | saldo atual ${myBalance}`;
};

No exemplo acima, apesar de termos omitido alguns passos, conseguimos criar um código desacoplado, legível e de fácil entendimento. Isso foi possível graças à alta especialização do código, onde cada função é responsável por executar uma única ação.

Voltar ao topo

Open/Closed Principle

Recomendação

O princípio aberto/fechado diz que o comportamento de uma entidade deve ser aberto a extensões, mas fechado a modificações, em palavras mais simples, precisamos poder criar novos comportamentos sem alterar os já existentes.

Exemplo

Imagine que uma faculdade nos pediu para desenvolvermos um software que irá validar se os candidatos conseguiram passar no vestibular para determinado curso.

Para isso nós vamos precisar saber a nota do candidato, a nota de corte do curso e quantas vagas o curso possui, ou seja, temos duas regras variáveis: nota de corte e quantidade de vagas.

type Student = {
  name: string;
  examNote: number;
  course: Course;
}

type Course = {
  name: string;
  openings: number;
  minNote: number;
}

const students = [
  {
    name: 'John',
    examNote: 87,
    course: {
      name: 'ADM',
      openings: 40,
      minNote:  62,
    },
  },
  {
    name: 'Joe',
    examNote: 42,
    course: {
      name: 'ENG',
      openings: 20,
      minNote:  76,
    },
  },
  {
    name: 'Katy',
    examNote: 66,
    course: {
      name: 'MED',
      openings: 10,
      minNote:  85,
    },
  },
];

const rankingStudents = (students: Student[]) => {
  return students.sort((a, b) => a.examNote - b.examNote );
};

const hasOpening = (listLength: number, listLimit: number) => {
  return listLength < listLimit;
};

const hasNote = (studentNote: number, minNote: number) => {
  return studentNote >= minNote;
}

const approvedList = {
  ADM: [],
  ENG: [],
  MED: [],
}

const approvedStudents = (students: Student[]) => {
  return rankingStudents(students)
    .reduce((acc, { name, examNote, course }) => {
      const courseApprovedList = acc[course.name];

      if (!hasOpening(courseApprovedList.length, course.openings)) return acc;

      if (hasNote(examNote, course.minNote)) {
        acc[couse.name].push(name);
      }

      return acc;
    }, approvedList);
};

No exemplo construído logo acima, estamos montando a lista de aprovados de acordo com o número de vagas e a nota de corte de cada curso, sendo que ambos os dados são variáveis, ou seja, podemos adicionar qualquer curso que quisermos a esse software sem a necessidade de alterá-lo.

Voltar ao topo

Dependency Inversion Principle

Recomendação

Antes de entrar mais a fundo nas recomendações, vale a citação que o princípio de inversão de dependências anda em paralelo com a arquitetura de Injeção de Dependências, essa que não será abordada aqui.

O princípio de inversão de dependências consiste na implementação de uma dependência baseada em uma abstração, normalmente uma Interface, ao invés de um objeto, valor ou classe propriamente dito.

Exemplo

Diferente dos exemplos anteriores, aqui iremos utilizar da Orientação a Objeto para exemplificar, pois acredito que seja mais fácil de entender dessa forma.

Pense no seguinte cenário, temos uma pessoa e ela tem vários jogos para jogar, porém todos esses jogos são de RPG, logo suas ações são bem similares. O objetivo é criar uma classe Pessoa que possa jogar qualquer jogo de RPG.

export interface IGameRPG {
  fight(): number; // <- retorna o dano causado
  flee(): boolean; // <- retorna se conseguiu fugir ou não
  levelUp(): void;

  get level(): number; // <- nível do jogo
}

class Gamer {
  constructor(private gameRpg: IGameRPG) {}

  combat() {
    return this.gameRpg.fight();
  }

  escape() {
    return this.gameRpg.flee();
  }

  improve() {
    this.gameRpg.levelUp();
  }
}

class LightSouls implements IGameRPG {
  private _level: number = 1;

  // 10 à 100 de dano
  fight() {
    console.log('Bate, rola, rola, bate, potion, bate');

    return Math.floor(Math.random() * (100 - 10 + 1)) + 10;
  }

  // 30% de chance de fugir
  flee() {
    console.log('Correeeeee');

    return Math.random() < 0.3;
  }

  levelUp() {
    console.log("Welcome Home, ashen one. Speak thine heart's desire.");

    this._level += 1;
  }

  get level() {
    return this._level;
  }
}

export class MoOnline implements IGameRPG {
  private _level: number = 1;

  // 1000 à 10000 de dano
  fight() {
    console.log('Bate, bate, bate, bate, bate, potion, bate, bate');

    return Math.floor(Math.random() * (10000 - 1000 + 1)) + 1000;
  }

  // 60% de chance de fugir
  flee() {
    console.log('Sair da missão');

    return Math.random() < 0.6;
  }

  levelUp() {
    console.log('Acessando novo andar...');

    this._level += 1;
  }

  get level() {
    return this._level;
  }
}

const moOnline = new MoOnline();
const lightSouls = new LightSouls();

const moGamer = new Gamer(moOnline); // <- a classe Gamer recebe o jogo Mo Online
const soulsGamer = new Gamer(lightSouls); // <- a classe Gamer recebe o jogo Light Souls

moGamer.combat(); // Bate, bate, bate, bate, bate, potion, bate, bate
soulsGamer.combat(); // Bate, rola, rola, bate, potion, bate

Como podemos ver no exemplo acima, a classe Gamer pode receber qualquer jogo, desde que ele seja uma implementação da abstração IGameRPG.

Isso só é possível, pois estamos garantindo, através da interface IGameRPG, que todo a classe que a implemente vai ter os métodos fight, flee e levelUp.

Voltar ao topo

Repositório

~~Todos os exemplos~~ demonstrados aqui se encontram nesse repositório, fique a vontade para favoritar, clonar ou realizar um fork.

Este repositório está em construção. Novos exemplos serão adicionados em breve.

Voltar ao topo

Links Úteis

Voltar ao topo

Introdução ao Polimorfismo

Gabriel_Silvestre — Thu, 19 May 2022 21:21:03 +0000

Tabela de Conteúdo

Polimorfismo
Sobrescrita de Métodos
Classes Abstratas
Métodos Estáticos
Polimorfismo em Interfaces
Links Úteis

Polimorfismo

O que é?

Na programação, o Polimorfismo remete a capacidade de alterar o comportamento de determinado método de uma Super Classe em qualquer uma das Sub Classes que à herdem.

O que faz?

Como dito em sua definição, permite a alteração de comportamentos de um determinado método sem alterar sua assinatura, dessa forma podemos ter o mesmo método com diferentes comportamentos a depender da classe que o implementa.

Um exemplo disso seria os métodos de ciclo de vida no React, ao trabalharmos o React com classes definimos os métodos de ciclo de vida com diferentes comportamentos dependendo do componente, porém esses métodos continuam a ter o mesmo nome, parâmetros e tipo de retorno.

Tipos

Existem diferentes tipos de Polimorfismo dentro da POO (Programação Orientada a Objetos), porém nesse artigo iremos abordar apenas a Sobrescrita de Métodos com TypeScript.

Voltar ao topo

Sobrescrita de Métodos

O que é?

É a alteração do comportamento padrão de um método da Super Classe para um comportamento mais específico de uma Sub Classe, sendo que, se não o sobrescrevermos o método manterá o comportamento definido na Super Classe.

Sintaxe

Para sobrescrevermos um determinado método, tudo que precisamos fazer é instanciá-lo na Sub Classe e definirmos uma nova lógica.

Uma obervação, os parâmetros e o tipo de retorno do método a ser sobrescrito podem ser mantidos, no intuito de padronizar o método, sendo a única alteração, a lógica interna.

class Person {
  constructor(public name: string) {}

  move(): void {
    console.log(`${this.name} se move`);
  }
}

class Runner extends Person {
  move() {
    console.log(`${this.name} corre`);
  }
}

class Lazy extends Person {
  move() {
    console.log(`${this.name} anda devagar`);
  }
}

const john = new Person('John');
const runnerJohn = new Runner('John');
const lazyJohn = new Lazy('John');

john.move();  // John se move
runnerJohn.move();  // John corre
lazyJohn.move();  // John anda devagar

Voltar ao topo

Classes Abstratas

O que são?

São classes que atuam de forma similar a Interfaces, isso porque elas não podem ser instanciadas, apenas herdadas, possibilitando ainda a criação de métodos abstratos, esses que por sua vez só podem existir em Classes Abstratas e devem ser implementados em qualquer Sub Classe de uma Super Classe Abstrata.

A diferença de Classes Abstratas e Interfaces, é que nas classes podemos definir outros métodos e atributos que não são abstratos, ou seja, podem receber funcionalidade e valores.

Sintaxe

Para definirmos Classes/Métodos Abstratos utilizamos a palavra reservada abstract antes de suas definições.

Lembrando que tudo que for abstrato, não pode ser implementado, apenas definido, e nada nos impede de criarmos métodos comuns dentro de Classes Abstratas.

abstract class Person {
  constructor(public name: string) {}

  /*
  mesmo estando em uma classe abstrata, ainda podemos criar métodos comuns
  que não precisam ser obrigatoriamente implementados nas Sub Classes.
  */
  greetings() {
    console.log(`Eu me chamo ${this.name}`);
  }

  abstract move(): void;
}

class Runner extends Person {
  move() {  // o método abstrato precisa ser implementado nas Sub Classes
    console.log(`${this.name} corre`);
  }
}

class Lazy extends Person {
  move() {
    console.log(`${this.name} anda devagar`);
  }
}

const runnerJohn = new Runner('John');
const lazyJohn = new Lazy('John');

runnerJohn.move();  // John corre
runnerJohn.greetings();  // Eu me chamo John

lazyJohn.move();  // John anda devagar
lazyJohn.greetings();  // Eu me chamo John

Voltar ao topo

Métodos Estáticos

O que são?

São métodos que não interagem com as instancias da classe, ou seja, manipulam as informações ligadas a classe em si, não a instância.

Também existem os atributos estáticos que assim como os métodos estão vinculados a classe e não as instâncias.

Sintaxe

Para definirmos Métodos/Atributos Estáticos utilizamos a palavra reservada static antes de suas definições.

class GroupMember {
  private static groupSize = 0;

  constructor(public newPerson: string) {
    Group.addMember();
  }

  private static addMember() {
    this.groupSize += 1;
  }

  static get size() {
    return this.groupSize;
  }
}

console.log(GroupMember.size);  // 0
const member1 = new GroupMember('John');

console.log(GroupMember.size);  // 1
const member2 = new GroupMember('John');

console.log(GroupMember.size);  // 2

Voltar ao topo

Polimorfismo em Interfaces

O que é?

Assim como nas classes, as Interfaces também podem ser polimorfas, ou seja, ter diferentes comportamentos a depender da implementação. Esse é o comportamento padrão de toda a Interface, afinal só definimos a assinatura, parâmetros e retorno do método, enquanto a lógica interna fica por nossa conta.

Porém podemos ainda utilizar das Generics criar classes e até funções ainda mais dinâmicas, dessa forma o tipo será determinado no momento de sua criação e não na definição.

Sintaxe

Como dito acima, o comportamento padrão de métodos definidos na Interface é serem polimórficos, logo sua definição continua a mesma.

Já para utilizarmos Generics, tudo que precisamos fazer é nós utilizar dos símbolos de maior e menor <>, colocando entre eles uma letra ~~por convenção~~ em maiúsculo.

interface IGame<T> {
  title: string;
  platform: string;
  controls: T;
}

type FPSControls = {
  W: 'up',
  A: 'left',
  S: 'down',
  D: 'right',
}

class FPSGame extends IGame<FPSControls> {
  constructor(
    public title: string,
    public platform: string,
    public controls: FPSControls
  ) {}
}

type MOBAControls = {
  Q: 'firstAbility',
  W: 'secondAbility',
  E: 'thirdAbility',
  R: 'ultimate',
}

class MOBAGame extends IGame<MOBAControls> {
  constructor(
    public title: string,
    public platform: string,
    public controls: MOBAControls
  ) {}
}

Voltar ao topo

Links Úteis

Voltar ao topo

DEV Community: Gabriel_Silvestre

Introdução MCP

MCP

O que é?

Porque usar?

Como usar?

Comunicação Interna

Protocol layer

Transport layer

Message types

Resources

Exemplo (da própria documentação)

Prompts

Exemplo (da própria documentação)

Tools

Exemplo (da própria documentação)

Introdução as HOFs - .some() e .every()

Tabela de Conteúdo

.some()

O que faz?

Sintaxe

Tradução - JavaScript -> Português

.every()

O que faz?

Sintaxe

Tradução - JavaScript -> Português

Links Úteis

.some()

.every()

Introdução as HOFs - .forEach() e .sort()

Tabela de Conteúdo

.forEach()

O que faz?

Sintaxe

Tradução - JavaScript -> Português

.sort()

O que faz?

Sintaxe

Tradução - JavaScript -> Português

Links Úteis

.forEach()

.sort()

MongoDB + Node

Tabela de Conteúdo

Mongoose

O que é?

O que faz?

Instalação

URI

O que é?

Sintaxe

Schemas

O que são?

O que fazem?

Sintaxe

Models

O que são?

O que fazem?

Sintaxe

Links Úteis

MongoDB - Updates Complexos

Tabela de Conteúdos

Modificadores de Atualizações em Arrays

O que são?

Onde/Quando utilizar?

Quais são?

Sintaxe

Operador $push

O que é?

Sintaxe

Operador $pop

O que é?

Sintaxe

Operador $pull

O que é?

Sintaxe

Operador $addToSet

O que é?

Sintaxe

Filtros em Arrays

Operador `$push`

Operador `$pop`

Operador `$pull`

Operador `$addToSet`

`$all`

`$elemMatch`

`$size`

`$expr`

`$regex`

`$mod`

`$lt`

`$lte`

`$gt`

`$gte`

`$eq`

`$ne`

`$in`

`$nin`

`$not`