Criar esquemas do Data Connect

Com Firebase Data Connect, você cria um esquema GraphQL que representa o modelo de dados necessário para seu aplicativo. Data Connect converte esse esquema na instância do Cloud SQL para PostgreSQL que oferece suporte ao app. Você então cria consultas e mutações para interagir com o back-end e agrupa essas operações em conectores para usar os dados do código do cliente.

Data Connect oferece ferramentas de IA para ajudar você a criar e implementar seus esquemas. Este guia apresenta conceitos importantes de design de esquema para oferecer suporte e complementar seus fluxos de trabalho padrão e com assistência de IA ao começar a desenvolver um appe muito mais.

O guia de introdução apresentou um esquema de app de avaliação de filmes para PostgreSQL.

Este guia desenvolve esse esquema e fornece uma listagem de SQL equivalente ao esquema final do app de avaliação de filmes.

O esquema de um app de avaliação de filmes

Imagine que você quer criar um serviço que permita aos usuários enviar e visualizar avaliações de filmes.

Você precisa de um esquema inicial para que um app desse tipo ofereça suporte a consultas básicas. Você vai estender esse esquema mais tarde para criar consultas relacionais complexas.

Em Data Connect, você define tipos GraphQL para definir o formato dos dados que seus clientes podem consultar e manipular. Ao escrever o esquema, os tipos são convertidos em tabelas do Cloud SQL para PostgreSQL, geralmente em uma relação direta entre os tipos GraphQL e as tabelas de banco de dados, embora outros mapeamentos sejam possíveis. Este guia mostra alguns exemplos, do básico ao mais avançado.

Definir um tipo Movie básico

Você pode começar com um tipo Movie.

O esquema de Movie contém diretivas principais, como:

• @table(name) e @col(name) para personalizar os nomes da tabela e da coluna SQL. Data Connect gera nomes snake_case se não forem especificados.
• @col(dataType) para personalizar os tipos de coluna SQL.
• @default para configurar os valores padrão da coluna SQL durante a inserção.

Para mais detalhes, consulte os documentos de referência de @table, @col, @default.

# Movies
type Movie @table(name: "movie", key: "id") {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int
  genre: String @col(dataType: "varchar(20)")
  rating: Int
  description: String
}

Armazenar dados importantes do usuário automaticamente em um tipo User

Seu app vai acompanhar os usuários, então você precisa de um tipo User.

A diretiva @default é especialmente útil nesse caso. O campo id aqui pode buscar automaticamente o ID do usuário na autenticação: observe o uso de @default(expr: "auth.uid") no exemplo a seguir.

# Users
# Suppose a user can leave reviews for movies
type User @table {
  id: String! @default(expr: "auth.uid")
  username: String! @col(dataType: "varchar(50)")
}

Escalares de chave e valores do servidor

Antes de analisar melhor o app de avaliação de filmes, é importante apresentar Data Connect escalares de chave e valores do servidor.

Escalares de chave são identificadores de objetos concisos que Data Connect monta automaticamente a partir de campos de chave nos seus esquemas. Os escalares de chave são sobre eficiência, permitindo que você encontre em uma única chamada informações sobre a identidade e a estrutura dos seus dados. Eles são especialmente úteis quando você quer realizar ações sequenciais em novos registros e precisa de um identificador exclusivo para transmitir às próximas operações, e também quando você quer acessar chaves relacionais para realizar outras operações mais complexas.

Usando valores do servidor, você pode permitir que o servidor preencha dinamicamente campos nas tabelas usando valores armazenados ou facilmente calculáveis de acordo com expressões CEL específicas do lado do servidor no expr argumento. Por exemplo, você pode definir um campo com um carimbo de data/hora aplicado quando o campo é acessado usando o horário armazenado em uma solicitação de operação, updatedAt: Timestamp! @default(expr: "request.time").

Processar relações de muitos para muitos nos tipos Actor e MovieActor

Com os usuários tratados, você pode voltar a modelar dados de filmes.

Em seguida, você quer que os atores estrelam seus filmes.

A tabela Actor é bem simples.

# Actors
# Suppose an actor can participate in multiple movies and movies can have multiple actors
# Movie - Actors (or vice versa) is a many to many relationship
type Actor @table {
  id: UUID! @default(expr: "uuidV4()")
  name: String! @col(dataType: "varchar(30)")
}

Se você quiser que os atores estejam em vários filmes e que os filmes tenham vários atores, precisará de uma "tabela de junção".

A tabela MovieActor processa a relação muitos para muitos, e a chave primária é uma combinação de [movie, actor] (os campos de chave externa de movie e actor).

# Join table for many-to-many relationship for movies and actors
# The 'key' param signifies the primary keys of this table
# In this case, the keys are [movieId, actorId], the foreign key fields of the reference fields [movie, actor]
type MovieActor @table(key: ["movie", "actor"]) {
  movie: Movie!
  # movieId: UUID! <- implicitly added foreign key field
  actor: Actor!
  # actorId: UUID! <- implicitly added foreign key field
  role: String! # "main" or "supporting"
  # optional other fields
}

Quando você define uma relação SQL na tabela com uma restrição de chave externa, Data Connect gera automaticamente o campo correspondente do outro lado. Não é necessário definir o campo de mapeamento reverso (por exemplo, de Actor de volta para MovieActor).

Processar relações de um para um em um tipo MovieMetadata

Agora, acompanhe os diretores de filmes e configure uma relação um para um com Movie.

Você pode usar a diretiva @ref para personalizar restrições de chave externa:

• @ref(fields) especifica quais campos de chave externa usar.
• @ref(references) especifica os campos referenciados na tabela de destino (o padrão é a chave primária, mas os campos @unique também funcionam). Essa é uma opção mais avançada. Data Connect geralmente pode inferir isso para você.

Para mais detalhes, consulte os documentos de referência de @ref.

# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata @table {
  # @unique ensures that each Movie only has one MovieMetadata.
  movie: Movie! @unique
  # Since it references to another table type, it adds a foreign key constraint.
  #  movie: Movie! @unique @ref(fields: "movieId", references: "id")
  #  movieId: UUID! <- implicitly added foreign key field
  director: String
}

Usar campos gerados pelo esquema para criar operações

As operações do Data Connect vão estender um conjunto de campos gerados automaticamente pelo Data Connect com base nos tipos e nas relações de tipo no esquema. Esses campos são gerados por ferramentas locais sempre que você edita o esquema.

query GetMovie($myKey: Movie_Key!) {
  movie(key: $myKey) { title }
}

query GetMovies($myYear: Int!) {
  movies(where: { year: { eq: $myYear } }) { title }
}

  query GetActorsOnMovie($myKey: Movie_Key!) {
    actors_on_movies(where: { movie: { key: { eq: $myKey } } }) {
      actor { name }
    }
  }

enum AspectRatio {
   ACADEMY
   WIDESCREEN
   ANAMORPHIC
   IMAX
   "No information available on aspect ratio"
   UNAVAILABLE
}

type Movie
  @table {
  title: String! 
  genre: String
  description: String
  originalAspectRatio: AspectRatio! @default(value: WIDESCREEN)
  otherAspectRatios: [AspectRatio!]
  tags: [String]
  rating: Float
  imageUrl: String!
  releaseYear: Int
}

-- Movies Table
CREATE TABLE Movies (
    movie_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    release_year INT,
    genre VARCHAR(30),
    rating INT,
    description TEXT,
    tags TEXT[]
);
-- Movie Metadata Table
CREATE TABLE MovieMetadata (
    movie_id UUID REFERENCES Movies(movie_id) UNIQUE,
    director VARCHAR(255) NOT NULL,
    PRIMARY KEY (movie_id)
);
-- Actors Table
CREATE TABLE Actors (
    actor_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    name VARCHAR(30) NOT NULL
);
-- MovieActor Join Table for Many-to-Many Relationship
CREATE TABLE MovieActor (
    movie_id UUID REFERENCES Movies(movie_id),
    actor_id UUID REFERENCES Actors(actor_id),
    role VARCHAR(50) NOT NULL, # "main" or "supporting"
    PRIMARY KEY (movie_id, actor_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id),
    FOREIGN KEY (actor_id) REFERENCES Actors(actor_id)
);
-- Users Table
CREATE TABLE Users (
    user_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_auth VARCHAR(255) NOT NULL
    username VARCHAR(30) NOT NULL
);
-- Reviews Table
CREATE TABLE Reviews (
    review_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_id UUID REFERENCES Users(user_id),
    movie_id UUID REFERENCES Movies(movie_id),
    rating INT,
    review_text TEXT,
    review_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE (movie_id, user_id)
    FOREIGN KEY (user_id) REFERENCES Users(user_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id)
);
-- Self Join Example for Movie Sequel Relationship
ALTER TABLE Movies
ADD COLUMN sequel_to UUID REFERENCES Movies(movie_id);