GraphQL Query returning null. Not sure why though

Question

I'm having some trouble with a graphQL query returning null and i'm not quite sure why its returning null. I've read several posts similar to this post but none of those posts have helped identify my exact problem.

I think it has something to do with how i'm passing/getting parameters, since my query with no parameters works fine, but i'm not sure since I can't find any other examples online.

Any help would be greatly appreciated.

I'm using apollo-server, graphql, and a community SQL datasource implementation which uses Knex to create a database connection.

There are two queries I can make.

1. allParts() - this query works as expected and returns all parts in my database with requested graphQL fields
2. getPart(itemnum) - this is the query that is not currently working.

graphQL Query:

query {
  getPart(itemnum: "T|0000000000001"){
    desc
  }
}

graphQL response:

"message": "Cannot return null for non-nullable field Part.desc.",

SQL query that is being executed based on Knex debug message:

method: 'select',
  options: {},
  timeout: false,
  cancelOnTimeout: false,
  bindings: [ 'T|0000000000001' ],
  __knexQueryUid: '3a8234eb-0a5c-46db-ad8e-5508288c9a86',
  sql: 'select * from `part` where `itemnum` = ?'

index.js:

const { ApolloServer } = require('apollo-server');
const typeDefs = require('./schema');
const resolvers = require ('./resolvers')
const PartAPI = require ('./datasources/partAPI');

const knexConfig = {
  client: "sqlite3",
  connection: {
    /* CONNECTION INFO */
    filename: "./TEAM_material.db3"
  },
  debug: true
};



const server = new ApolloServer({ 
    typeDefs,
    resolvers,
    dataSources: () => ({
      partAPI: new PartAPI(knexConfig),
    }),
    introspection: true,
 });

server.listen().then(({ url }) => {
    console.log(`🚀 Server ready at ${url}`);
  });

partAPI.js:

const { SQLDataSource } = require("datasource-sql");



const MINUTE = 60;

class PartAPI extends SQLDataSource {

    getPart(itemnum){
        return this.knex.select('*').from('part').where({itemnum});
    }

    getAllParts(){
        const query = this.knex.select('*').from('part').cache(MINUTE);
        console.log (query);
        return query;
    }
}

module.exports = PartAPI;

schema.js

// src/schema.js

const { gql } = require('apollo-server')

const typeDefs = gql`
#Types
    type Part {
        itemnum: String!
        desc: String!
        vendor: String!
        manuf: String!
        venlist: Float!
        price: Float!
        teamlist: Float!
        teamsell: Float!
        unitypart: String!
        pkgqty: Int!
        ioType: String!
        preferred: Boolean!
        filterlvl1: String!
        filterlvl2: String!
        filterlvl3: String!
        filterlvl4: String!
        ipwiretype: String!
        opwiretype: String!
        obsolete: Boolean!
    }
#Queries
    type Query {
        getPart(itemnum: String!): Part
        allParts: [Part!]!
    }
`;

module.exports = typeDefs

resolvers.js

// src/resolvers.js

const resolvers = {
    Query: {
       getPart: (_,args,{dataSources}) => dataSources.partAPI.getPart(args.itemnum),
       allParts: (_,__,{dataSources}) => dataSources.partAPI.getAllParts(),
      },
};

module.exports = resolvers

Answer 1

turns out my schema was incorrect. The getPart query was expecting a Part but instead my query was returning an array of Part.

old Schema

#Queries
    type Query {
        getPart(itemnum: String!): Part
        allParts: [Part!]!
    }
`;

new Schema

#Queries
    type Query {
        getPart(itemnum: String!): [Part]!
        allParts: [Part!]!
    }
`;