Les objets référencés dans la base de données renvoient null dans la requête GraphQL

Question

J'ai le modèle de base de données suivant :

• Chaque Mediablock contient une référence exactement à un objet UTS et un objet Media.

• Chaque objet UTS contient rawText et normalisedText

• Chaque objet Media contient une URL et un horodatage

Mon fichier schema.prisma ressemble à ceci :

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Mediablock {
  id      String @id @default(auto()) @map("_id") @db.ObjectId // gen a new, unique id
  UTS     UTS    @relation(fields: [utsId], references: [id])
  utsId   String @unique @map("uts_id") @db.ObjectId
  Media   Media  @relation(fields: [mediaId], references: [id])
  mediaId String @unique @map("media_id") @db.ObjectId
}

model UTS {
  id             String      @id @default(auto()) @map("_id") @db.ObjectId
  rawText        String
  normalisedText String
  createdAt      DateTime    @default(now())
  Mediablock     Mediablock?
}

// // Mediablocks contain a Video object and connect back to the Mediablock.
// // mediablockId must have @db.ObjectId to match up with Mediablock's id type
model Media {
  id         String      @id @default(auto()) @map("_id") @db.ObjectId
  url        String
  createdAt  DateTime    @default(now())
  Mediablock Mediablock?
}

Mes résolveurs ressemblent à ceci :

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

// Ce résolveur récupère des mediabooks du tableau "mediabooks" ci-dessus.
module.exports = {
  Query: {
    allMediablocks: () => prisma.mediablock.findMany(),
    allMedia: () => prisma.media.findMany(),
    allUTS: () => prisma.uts.findMany(),
  },
};

Et mes typedefs ressemblent à ceci :

module.exports = `
  type Mediablock {
    id: ID!
    uts: UTS
    media: Media # peut être nul lorsque le texte est généré en premier
  }

  type UTS {
    id: ID!
    rawText: String!
    normalisedText: String!
  }

  type Media {
    id: ID!
    url: String!
    createdAt: String!
  }

  # Le type "Query" est spécial : il répertorie toutes les requêtes disponibles que
  # les clients peuvent exécuter, avec le type de retour pour chacune. Dans ce
  # cas, la requête "allMediablocks" renvoie un tableau de zéro ou plusieurs Mediablocks (défini ci-dessus).
  type Query {
    allMediablocks: [Mediablock]
    allMedia: [Media]
    allUTS: [UTS]
  }
`;

Mon fichier seed ressemble à ceci :

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

const mediaData = [
  {
    UTS: {
      create: {
        rawText: 'Welcome',
        normalisedText: 'welcome',
      },
    },
    Media: {
      create: {
        url: 'https://www.youtube.com/watch?v=kq9aShH2Kg4',
        createdAt: '2022-09-29T12:00:00.000Z',
      }
    }
  }
];

async function main() {
  console.log(`Started seeding ...`);

  for (const d of mediaData) {

    const mediablock = await prisma.Mediablock.create({
      data: d,
    });

    console.log(`Created Mediablock with id: ${mediablock.id}`);

  }

  console.log(`\nSeeding complete.`);
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });

Mon problème est que lorsque j'essaie de récupérer allMediablocks, je ne peux pas obtenir les données UTS ou Media.

query allMediaBlocks {
  allMediablocks {
    uts {
      normalisedText
    }
    media {
      url
    }
  }
}

// réponse
{
  "data": {
    "allMediablocks": [
      {
        "uts": null,
        "media": null
      }
    ]
  }
}

Je reçois simplement des valeurs null pour les deux, alors qu'en réalité, la base de données (MongoDB) contient des références à ces deux objets dans d'autres tables.

Qu'est-ce que je fais de travers ? Mes résolveurs sont-ils incorrects ? Est-ce que mon schéma est structuré incorrectement pour MongoDB ?

Answer 1

J'ai corrigé en changeant mon schema.prisma pour être:

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Mediablock {
  id      String @id @default(auto()) @map("_id") @db.ObjectId // génère un nouvel identifiant unique
  utsId   String @unique @map("uts_id") @db.ObjectId
  uts     UTS    @relation(fields: [utsId], references: [id])
  mediaId String @unique @map("media_id") @db.ObjectId
  media   Media  @relation(fields: [mediaId], references: [id])
}

model UTS {
  id             String      @id @default(auto()) @map("_id") @db.ObjectId
  rawText        String
  normalisedText String
  createdAt      DateTime    @default(now())
  mediablock     Mediablock?
}

// // Les Mediablocks contiennent un objet Vidéo et se connectent de nouveau au Mediablock.
// // mediablockId doit avoir @db.ObjectId pour correspondre au type d’identifiant de Mediablock
model Media {
  id         String      @id @default(auto()) @map("_id") @db.ObjectId
  url        String
  createdAt  DateTime    @default(now())
  mediablock Mediablock?
}

Mon resolver pour être:

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

// Ce resolver récupère des mediablocks à partir du tableau "mediablocks" ci-dessus.
module.exports = {
  Query: {
    allMediablocks: () => prisma.mediablock.findMany({
      include: {
        media: true,
        uts: true
      }
    }),
    allMedia: () => prisma.media.findMany(),
    allUTS: () => prisma.uts.findMany(),
  },
};

Et mes typedefs pour être:

module.exports = `
  type Mediablock {
    id: ID!
    uts: UTS
    media: Media # peut être nul lorsque le texte est généré pour la première fois
  }

  type UTS {
    id: ID!
    rawText: String!
    normalisedText: String!
  }

  type Media {
    id: ID!
    url: String!
    createdAt: String!
  }

  # Le type "Query" est spécial: il répertorie toutes les requêtes disponibles que
  # les clients peuvent exécuter, avec le type de retour pour chacune. Dans ce
  # cas, la requête "allMediablocks" renvoie un tableau de zéro ou plusieurs Mediablocks (définis ci-dessus).
  type Query {
    allMediablocks: [Mediablock]
    allMedia: [Media]
    allUTS: [UTS]
  }
`;

J'ai aussi modifié le fonctionnement de ma fonction seed :

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

const mediaData = [
  {
    uts: {
      create: {
        rawText: 'Welcome',
        normalisedText: 'welcome',
        createdAt: '2022-09-29T12:00:00.000Z',
      },
    },
    media: {
      create: {
        url: 'https://www.youtube.com/watch?v=kq9aShH2Kg4',
        createdAt: '2022-09-29T12:00:00.000Z',
      }
    }
  }
];

async function main() {
  console.log(`Démarrage du seeding ...`);

  for (const d of mediaData) {

    const mediablock = await prisma.Mediablock.create({
      data: d,
    });

    console.log(mediablock);

  }

  console.log(`\nSeeding complet.`);
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });

Maintenant, en utilisant la même requête GraphQL :

query allMediaBlocks {
  allMediablocks {
    uts {
      normalisedText
    }
    media {
      url
    }
  }
}

Je reçois la réponse suivante (désirée) :

{
  "data": {
    "allMediablocks": [
      {
        "uts": {
          "normalisedText": "welcome"
        },
        "media": {
          "url": "https://www.youtube.com/watch?v=kq9aShH2Kg4"
        }
      }
    ]
  }
}