Construir Perfis de Usuário no MongoDB

Introdução

Neste laboratório, você aprenderá como criar e gerenciar perfis de usuário no MongoDB. Você começará projetando um esquema básico, depois aprenderá como atualizar documentos, trabalhar com arrays para interesses de usuários e gerenciar configurações complexas aninhadas. Ao final deste laboratório, você terá uma compreensão sólida dos conceitos fundamentais de modelagem de dados do MongoDB para construir perfis de usuário flexíveis e escaláveis em suas aplicações.

Criar um Perfil de Usuário Básico

Nesta primeira etapa, você criará um novo banco de dados e inserirá seu primeiro documento de perfil de usuário. Isso estabelecerá a estrutura básica para armazenar informações do usuário.

Primeiro, abra o shell interativo do MongoDB a partir do seu terminal. Esta é a ferramenta principal para interagir com seu banco de dados MongoDB.

mongosh

Uma vez dentro do shell, você verá um prompt test>. Vamos mudar para um novo banco de dados chamado userprofiles_db. Se o banco de dados não existir, o MongoDB o criará para você quando você armazenar dados pela primeira vez.

use userprofiles_db

Agora, você inserirá um documento em uma coleção chamada profiles. Um documento no MongoDB é uma estrutura BSON (semelhante a JSON binário), e uma coleção é um grupo de documentos relacionados.

Execute o seguinte comando para inserir um perfil para um usuário chamado johndoe.

db.profiles.insertOne({
  username: "johndoe",
  personal_info: {
    first_name: "John",
    last_name: "Doe",
    email: "john.doe@example.com"
  },
  metadata: {
    created_at: new Date(),
    account_status: "active"
  }
});

Este comando usa o método insertOne() para adicionar um único documento. O documento contém um username, um objeto aninhado personal_info e um objeto metadata para rastrear o tempo de criação e o status da conta.

Para confirmar que o documento foi criado com sucesso, você pode usar o método find() para recuperá-lo.

db.profiles.find({ username: "johndoe" });

Você deverá ver o documento que acabou de inserir, juntamente com um campo _id exclusivo adicionado automaticamente pelo MongoDB. A data e o ObjectId serão diferentes na sua saída.

[
  {
    _id: ObjectId('656f1a7b2e3a4c5d6e7f8b9a'),
    username: 'johndoe',
    personal_info: {
      first_name: 'John',
      last_name: 'Doe',
      email: 'john.doe@example.com'
    },
    metadata: {
      created_at: ISODate('2023-12-05T10:30:51.123Z'),
      account_status: 'active'
    }
  }
]

Adicionar e Atualizar Informações do Perfil

Nesta etapa, você aprenderá como modificar um documento existente. Adicionaremos informações de contato mais detalhadas ao perfil de usuário criado na etapa anterior.

Usaremos o método updateOne() para atualizar o perfil johndoe. Este método recebe dois argumentos: um filtro para encontrar o documento a ser atualizado e um documento de atualização que especifica as alterações.

Vamos adicionar um objeto contact_details. Usaremos o operador $set, que substitui o valor de um campo pelo valor especificado. Se o campo não existir, $set adiciona um novo campo.

db.profiles.updateOne(
  { username: "johndoe" },
  {
    $set: {
      contact_details: {
        phone: "+1-555-1234",
        address: {
          street: "123 Main St",
          city: "San Francisco",
          country: "USA"
        }
      },
      "metadata.last_updated": new Date()
    }
  }
);

Neste comando, adicionamos um novo objeto contact_details. Também usamos a notação de ponto ("metadata.last_updated") para adicionar um campo last_updated ao objeto metadata existente sem substituí-lo. Este é um recurso poderoso para atualizar campos aninhados.

Vamos recuperar o documento novamente para ver as alterações.

db.profiles.find({ username: "johndoe" });

A saída agora mostrará os contact_details recém-adicionados e o timestamp last_updated em metadata.

[
  {
    _id: ObjectId('656f1a7b2e3a4c5d6e7f8b9a'),
    username: 'johndoe',
    personal_info: {
      first_name: 'John',
      last_name: 'Doe',
      email: 'john.doe@example.com'
    },
    metadata: {
      created_at: ISODate('2023-12-05T10:30:51.123Z'),
      account_status: 'active',
      last_updated: ISODate('2023-12-05T10:35:22.456Z')
    },
    contact_details: {
      phone: '+1-555-1234',
      address: {
        street: '123 Main St',
        city: 'San Francisco',
        country: 'USA'
      }
    }
  }
]

Trabalhar com Arrays em Perfis

Perfis de usuário frequentemente contêm listas de itens, como interesses, habilidades ou tags. O MongoDB lida com isso de forma eficiente usando arrays. Nesta etapa, você adicionará e modificará um array de interesses em nosso perfil de usuário.

Primeiro, vamos adicionar um array interests ao perfil johndoe usando o operador $set.

db.profiles.updateOne(
  { username: "johndoe" },
  { $set: { interests: ["technology", "travel"] } }
);

Agora, suponha que o usuário desenvolva um novo interesse. Em vez de substituir o array inteiro, podemos adicionar um novo elemento a ele usando o operador $push. Este operador anexa um valor especificado a um array e é mais eficiente para adições.

db.profiles.updateOne(
  { username: "johndoe" },
  { $push: { interests: "photography" } }
);

Vamos visualizar o perfil atualizado para ver o novo interesse. Podemos usar projeção no método find para mostrar apenas os campos username e interests. Definir um campo como 1 o inclui, e definir _id como 0 o exclui, o que mantém a saída limpa.

db.profiles.find(
  { username: "johndoe" },
  { username: 1, interests: 1, _id: 0 }
);

A saída mostrará o array interests com o elemento recém-adicionado.

[
  {
    "username": "johndoe",
    "interests": ["technology", "travel", "photography"]
  }
]

Você também pode consultar usuários com base nos elementos em seus arrays. Por exemplo, para encontrar todos os usuários interessados em "technology":

db.profiles.find({ interests: "technology" });

Gerenciar Dados Aninhados Complexos

Aplicações do mundo real frequentemente exigem o armazenamento de configurações complexas, como as preferências do usuário. O suporte do MongoDB para documentos aninhados é ideal para isso. Nesta etapa, você adicionará e atualizará um objeto settings detalhado no perfil.

Primeiro, vamos adicionar um objeto settings com campos aninhados para theme, language e notifications.

db.profiles.updateOne(
  { username: "johndoe" },
  {
    $set: {
      settings: {
        theme: "dark",
        language: "en",
        notifications: {
          email: true,
          sms: false
        }
      }
    }
  }
);

Agora, vamos atualizar um único campo aninhado sem reescrever todo o objeto settings. Podemos fazer isso novamente usando a notação de ponto. Vamos habilitar as notificações por SMS para o usuário.

db.profiles.updateOne(
  { username: "johndoe" },
  { $set: { "settings.notifications.sms": true } }
);

Este comando visa precisamente o campo sms dentro do objeto aninhado notifications e altera seu valor para true, deixando o restante do objeto settings inalterado.

Para verificar a alteração, vamos recuperar apenas o objeto settings do nosso usuário usando projeção.

db.profiles.find({ username: "johndoe" }, { settings: 1, _id: 0 });

A saída mostrará o objeto settings atualizado com sms agora definido como true.

[
  {
    "settings": {
      "theme": "dark",
      "language": "en",
      "notifications": { "email": true, "sms": true }
    }
  }
]

Você completou agora as etapas práticas deste laboratório. Para sair do shell do MongoDB, você pode digitar exit ou pressionar Ctrl+D.

exit;

Resumo

Neste laboratório, você aprendeu os fundamentos da construção de perfis de usuário no MongoDB. Você começou criando um documento de usuário básico e, em seguida, progrediu para atualizá-lo com novas informações usando o operador $set. Você também aprendeu a gerenciar listas de dados usando arrays e o operador $push, e como estruturar e modificar configurações complexas com documentos aninhados usando a notação de ponto. Essas habilidades são essenciais para projetar esquemas flexíveis e escaláveis para qualquer aplicação que gerencie dados de usuários no MongoDB.