fix(schema): invalid empty GraphQL types caused by specific CSN definitions

CHANGELOG.md

@@ -9,10 +9,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Schema validation after schema generation (on server startup or manual compilation) to ensure that the generated schema is valid according to the GraphQL specification
+- Scalar type `Void` that represents the absence of a return value and only allows value `null`
+
 ### Changed
 
 ### Fixed
 
+- Improved schema generation robustness where specific CDS modelling could cause empty GraphQL types to be generated (which is not allowed) for entities, aspects and services. These types and any resulting empty parent types are omitted from the generated schema and a warning is logged for them. If schema generation would result in an empty query root type, a placeholder field `_` of type `Void` is added to keep the schema valid.
+
 ### Removed
 
 ## Version 0.12.0 - 2025-05-05

lib/resolvers/field.js

@@ -3,7 +3,7 @@ const { isObjectType, isIntrospectionType } = require('graphql')
 // The GraphQL.js defaultFieldResolver does not support returning aliased values that resolve to fields with aliases
 function aliasFieldResolver(source, args, contextValue, info) {
   const responseKey = info.fieldNodes[0].alias ? info.fieldNodes[0].alias.value : info.fieldName
-  return source[responseKey]
+  return source?.[responseKey]
 }
 
 const registerAliasFieldResolvers = schema => {

lib/schema/args/filter.js

@@ -25,23 +25,23 @@ const {
 
 module.exports = cache => {
   const generateFilterForEntity = entity => {
+    if (!hasScalarFields(entity)) return
+
     const filterName = gqlName(entity.name) + '_filter'
 
-    const cachedFilterInputType = cache.get(filterName)
-    if (cachedFilterInputType) return cachedFilterInputType
-    if (!hasScalarFields(entity)) return
+    if (cache.has(filterName)) return cache.get(filterName)
 
     const fields = {}
-    const newFilterInputType = new GraphQLList(new GraphQLInputObjectType({ name: filterName, fields: () => fields }))
-    cache.set(filterName, newFilterInputType)
+    const filterInputType = new GraphQLList(new GraphQLInputObjectType({ name: filterName, fields: () => fields }))
+    cache.set(filterName, filterInputType)
 
     for (const name in entity.elements) {
       const element = entity.elements[name]
       const type = generateFilterForElement(element)
       if (type) fields[gqlName(name)] = { type }
     }
 
-    return newFilterInputType
+    return filterInputType
   }
 
   const generateFilterForElement = (element, followAssocOrComp) => {
@@ -84,15 +84,14 @@ module.exports = cache => {
   const _generateFilterType = (gqlType, operations) => {
     const filterName = gqlType.name + '_filter'
 
-    const cachedFilterType = cache.get(filterName)
-    if (cachedFilterType) return cachedFilterType
+    if (cache.has(filterName)) return cache.get(filterName)
 
     const ops = operations.map(op => [[op], { type: OPERATOR_LIST_SUPPORT[op] ? new GraphQLList(gqlType) : gqlType }])
     const fields = Object.fromEntries(ops)
-    const newFilterType = new GraphQLInputObjectType({ name: filterName, fields })
-    cache.set(filterName, newFilterType)
+    const filterType = new GraphQLInputObjectType({ name: filterName, fields })
+    cache.set(filterName, filterType)
 
-    return newFilterType
+    return filterType
   }
 
   return { generateFilterForEntity, generateFilterForElement }

lib/schema/args/input.js

@@ -8,12 +8,11 @@ module.exports = cache => {
     const suffix = isUpdate ? '_U' : '_C'
     const entityName = gqlName(entity.name) + suffix
 
-    const cachedEntityInputObjectType = cache.get(entityName)
-    if (cachedEntityInputObjectType) return cachedEntityInputObjectType
+    if (cache.has(entityName)) return cache.get(entityName)
 
     const fields = {}
-    const newEntityInputObjectType = new GraphQLInputObjectType({ name: entityName, fields: () => fields })
-    cache.set(entityName, newEntityInputObjectType)
+    const entityInputObjectType = new GraphQLInputObjectType({ name: entityName, fields: () => fields })
+    cache.set(entityName, entityInputObjectType)
 
     for (const name in entity.elements) {
       const element = entity.elements[name]
@@ -22,9 +21,12 @@ module.exports = cache => {
     }
 
     // fields is empty if update input object is generated for an entity that only contains key elements
-    if (Object.keys(fields).length === 0) return
+    if (!Object.keys(fields).length) {
+      cache.set(entityName)
+      return
+    }
 
-    return newEntityInputObjectType
+    return entityInputObjectType
   }
 
   const _elementToInputObjectType = (element, isUpdate) => {
@@ -38,7 +40,7 @@ module.exports = cache => {
     if (element.isAssociation || element.isComposition) {
       // Input objects in deep updates overwrite previous entries with new entries and therefore always act as create input objects
       const type = gqlScalarType || entityToInputObjectType(element._target, false)
-      return element.is2one ? type : new GraphQLList(type)
+      if (type) return element.is2one ? type : new GraphQLList(type)
     } else if (gqlScalarType) {
       return gqlScalarType
     }

lib/schema/args/orderBy.js

@@ -5,23 +5,23 @@ const { cdsToGraphQLScalarType } = require('../types/scalar')
 
 module.exports = cache => {
   const generateOrderByForEntity = entity => {
+    if (!hasScalarFields(entity)) return
+
     const orderByName = gqlName(entity.name) + '_orderBy'
 
-    const cachedOrderByInputType = cache.get(orderByName)
-    if (cachedOrderByInputType) return cachedOrderByInputType
-    if (!hasScalarFields(entity)) return
+    if (cache.has(orderByName)) return cache.get(orderByName)
 
     const fields = {}
-    const newOrderByInputType = new GraphQLList(new GraphQLInputObjectType({ name: orderByName, fields: () => fields }))
-    cache.set(orderByName, newOrderByInputType)
+    const orderByInputType = new GraphQLList(new GraphQLInputObjectType({ name: orderByName, fields: () => fields }))
+    cache.set(orderByName, orderByInputType)
 
     for (const name in entity.elements) {
       const element = entity.elements[name]
       const type = generateOrderByForElement(element)
       if (type) fields[gqlName(name)] = { type }
     }
 
-    return newOrderByInputType
+    return orderByInputType
   }
 
   const generateOrderByForElement = (element, followAssocOrComp) => {
@@ -38,16 +38,15 @@ module.exports = cache => {
   const _generateSortDirectionEnum = () => {
     const enumName = 'SortDirection'
 
-    const cachedSortDirectionEnum = cache.get(enumName)
-    if (cachedSortDirectionEnum) return cachedSortDirectionEnum
+    if (cache.has(enumName)) return cache.get(enumName)
 
-    const newSortDirectionEnum = new GraphQLEnumType({
+    const sortDirectionEnum = new GraphQLEnumType({
       name: enumName,
       values: { asc: { value: 'asc' }, desc: { value: 'desc' } }
     })
-    cache.set(enumName, newSortDirectionEnum)
+    cache.set(enumName, sortDirectionEnum)
 
-    return newSortDirectionEnum
+    return sortDirectionEnum
   }
 
   return { generateOrderByForEntity, generateOrderByForElement }

lib/schema/index.js

@@ -1,15 +1,24 @@
 const queryGenerator = require('./query')
 const mutationGenerator = require('./mutation')
-const { GraphQLSchema } = require('graphql')
+const { GraphQLSchema, validateSchema } = require('graphql')
 const { createRootResolvers, registerAliasFieldResolvers } = require('../resolvers')
 
 function generateSchema4(services) {
   const resolvers = createRootResolvers(services)
   const cache = new Map()
+
   const query = queryGenerator(cache).generateQueryObjectType(services, resolvers.Query)
   const mutation = mutationGenerator(cache).generateMutationObjectType(services, resolvers.Mutation)
   const schema = new GraphQLSchema({ query, mutation })
+
   registerAliasFieldResolvers(schema)
+
+  const schemaValidationErrors = validateSchema(schema)
+  if (schemaValidationErrors.length) {
+    schemaValidationErrors.forEach(error => (error.severity = 'Error')) // Needed for cds-dk to decide logging based on log level
+    throw new AggregateError(schemaValidationErrors, 'GraphQL schema validation failed')
+  }
+
   return schema
 }
 

lib/schema/mutation.js

@@ -18,7 +18,7 @@ module.exports = cache => {
       if (type) fields[serviceName] = { type, resolve }
     }
 
-    if (Object.keys(fields).length === 0) return
+    if (!Object.keys(fields).length) return
 
     return new GraphQLObjectType({ name: 'Mutation', fields })
   }
@@ -36,7 +36,7 @@ module.exports = cache => {
       if (type) fields[entityName] = { type }
     }
 
-    if (Object.keys(fields).length === 0) return
+    if (!Object.keys(fields).length) return
 
     return new GraphQLObjectType({ name: gqlName(service.name) + '_input', fields })
   }
@@ -51,7 +51,7 @@ module.exports = cache => {
       }).filter(([_, v]) => v)
     )
 
-    if (Object.keys(fields).length === 0) return
+    if (!Object.keys(fields).length) return
 
     return new GraphQLObjectType({ name: gqlName(entity.name) + '_input', fields })
   }

lib/schema/query.js

@@ -1,23 +1,34 @@
+const cds = require('@sap/cds')
+const LOG = cds.log('graphql')
 const { GraphQLObjectType } = require('graphql')
 const { gqlName } = require('../utils')
 const objectGenerator = require('./types/object')
 const argsGenerator = require('./args')
 const { isCompositionOfAspect } = require('./util')
+const { GraphQLVoid } = require('./types/custom')
 
 module.exports = cache => {
   const generateQueryObjectType = (services, resolvers) => {
+    const name = 'Query'
     const fields = {}
 
     for (const key in services) {
       const service = services[key]
       const serviceName = gqlName(service.name)
-      fields[serviceName] = {
-        type: _serviceToObjectType(service),
-        resolve: resolvers[serviceName]
-      }
+      const type = _serviceToObjectType(service)
+      if (!type) continue
+      fields[serviceName] = { type, resolve: resolvers[serviceName] }
     }
 
-    return new GraphQLObjectType({ name: 'Query', fields })
+    // Empty root query object type is not allowed, so we add a placeholder field
+    if (!Object.keys(fields).length) {
+      fields._ = { type: GraphQLVoid }
+      LOG.warn(
+        `Root query object type "${name}" is empty. A placeholder field has been added to ensure a valid schema.`
+      )
+    }
+
+    return new GraphQLObjectType({ name, fields })
   }
 
   const _serviceToObjectType = service => {
@@ -30,11 +41,17 @@ module.exports = cache => {
 
       // REVISIT: requires differentiation for support of configurable schema flavors
       const type = objectGenerator(cache).entityToObjectConnectionType(entity)
+      if (!type) continue
       const args = argsGenerator(cache).generateArgumentsForType(entity)
 
       fields[gqlName(key)] = { type, args }
     }
 
+    if (!Object.keys(fields).length) {
+      LOG.warn(`Service "${service.name}" has no fields and has therefore been excluded from the schema.`)
+      return
+    }
+
     return new GraphQLObjectType({
       name: gqlName(service.name),
       // REVISIT: Passed services currently don't directly contain doc property

lib/schema/types/custom/GraphQLVoid.js

@@ -0,0 +1,15 @@
+const { GraphQLScalarType } = require('graphql')
+
+const serialize = () => null
+
+const parseValue = () => null
+
+const parseLiteral = () => null
+
+module.exports = new GraphQLScalarType({
+  name: 'Void',
+  description: 'The `Void` scalar type represents the absence of a value. Void can only represent the value `null`.',
+  serialize,
+  parseValue,
+  parseLiteral
+})

lib/schema/types/custom/index.js

@@ -7,5 +7,6 @@ module.exports = {
   GraphQLInt64: require('./GraphQLInt64'),
   GraphQLTime: require('./GraphQLTime'),
   GraphQLTimestamp: require('./GraphQLTimestamp'),
-  GraphQLUInt8: require('./GraphQLUInt8')
+  GraphQLUInt8: require('./GraphQLUInt8'),
+  GraphQLVoid: require('./GraphQLVoid')
 }

lib/schema/types/object.js

@@ -1,3 +1,5 @@
+const cds = require('@sap/cds')
+const LOG = cds.log('graphql')
 const { GraphQLObjectType, GraphQLList, GraphQLInt } = require('graphql')
 const { gqlName } = require('../../utils')
 const argsGenerator = require('../args')
@@ -9,46 +11,57 @@ module.exports = cache => {
   const entityToObjectConnectionType = entity => {
     const name = gqlName(entity.name) + '_connection'
 
-    const cachedEntityObjectConnectionType = cache.get(name)
-    if (cachedEntityObjectConnectionType) return cachedEntityObjectConnectionType
+    if (cache.has(name)) return cache.get(name)
 
     const fields = {}
-    const newEntityObjectConnectionType = new GraphQLObjectType({ name, fields: () => fields })
-    cache.set(name, newEntityObjectConnectionType)
+    const entityObjectConnectionType = new GraphQLObjectType({ name, fields: () => fields })
+    cache.set(name, entityObjectConnectionType)
 
-    fields[CONNECTION_FIELDS.nodes] = { type: new GraphQLList(entityToObjectType(entity)) }
+    const objectType = entityToObjectType(entity)
+    if (!objectType) {
+      cache.set(name)
+      return
+    }
+
+    fields[CONNECTION_FIELDS.nodes] = { type: new GraphQLList(objectType) }
     fields[CONNECTION_FIELDS.totalCount] = { type: GraphQLInt }
 
-    return newEntityObjectConnectionType
+    return entityObjectConnectionType
   }
 
   const entityToObjectType = entity => {
     const entityName = gqlName(entity.name)
 
-    const cachedEntityObjectType = cache.get(entityName)
-    if (cachedEntityObjectType) return cachedEntityObjectType
+    if (cache.has(entityName)) return cache.get(entityName)
 
     const fields = {}
-    const newEntityObjectType = new GraphQLObjectType({
+    const entityObjectType = new GraphQLObjectType({
       name: entityName,
       description: entity.doc,
       fields: () => fields
     })
-    cache.set(entityName, newEntityObjectType)
+    cache.set(entityName, entityObjectType)
 
     for (const name in entity.elements) {
       const element = entity.elements[name]
 
       // REVISIT: requires differentiation for support of configurable schema flavors
       const type = element.is2many ? _elementToObjectConnectionType(element) : _elementToObjectType(element)
-      if (type) {
-        const field = { type, description: element.doc }
-        if (element.is2many) field.args = argsGenerator(cache).generateArgumentsForType(element)
-        fields[gqlName(name)] = field
-      }
+      if (!type) continue
+
+      const field = { type, description: element.doc }
+      if (element.is2many) field.args = argsGenerator(cache).generateArgumentsForType(element)
+      fields[gqlName(name)] = field
+    }
+
+    // fields is empty e.g. for empty aspects
+    if (!Object.keys(fields).length) {
+      LOG.warn(`Entity "${entity.name}" has no fields and has therefore been excluded from the schema.`)
+      cache.set(entityName, undefined)
+      return
     }
 
-    return newEntityObjectType
+    return entityObjectType
   }
 
   const _elementToObjectType = element => {

test/resources/empty-csn-definitions/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "@cap-js/graphql": "*"
+  },
+  "devDependencies": {
+    "@cap-js/sqlite": "*"
+  }
+}