@sap/cds 5.5.3 → 5.6.1

package/libx/gql/resolvers/crud/index.js

@@ -0,0 +1,6 @@
+const executeCreate = require('./create')
+const executeRead = require('./read')
+const executeUpdate = require('./update')
+const executeDelete = require('./delete')
+
+module.exports = { executeCreate, executeRead, executeUpdate, executeDelete }

package/libx/gql/resolvers/crud/read.js

@@ -0,0 +1,25 @@
+const { ARGUMENT } = require('../../constants/adapter')
+const { getArgumentByName, astToColumns, astToWhere, astToOrderBy, astToLimit } = require('../parse/ast2cqn')
+
+module.exports = async (service, entityFQN, selection) => {
+  let query = service.read(entityFQN)
+  query.columns(astToColumns(selection.selectionSet.selections))
+
+  const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)
+  if (filter) {
+    query.where(astToWhere(filter))
+  }
+
+  const orderBy = getArgumentByName(selection.arguments, ARGUMENT.ORDER_BY)
+  if (orderBy) {
+    query.orderBy(astToOrderBy(orderBy))
+  }
+
+  const top = getArgumentByName(selection.arguments, ARGUMENT.TOP)
+  const skip = getArgumentByName(selection.arguments, ARGUMENT.SKIP)
+  if (top) {
+    query.limit(astToLimit(top, skip))
+  }
+
+  return await service.tx(tx => tx.run(query))
+}

package/libx/gql/resolvers/crud/update.js

@@ -0,0 +1,31 @@
+const { ARGUMENT } = require('../../constants/adapter')
+const { getArgumentByName, astToColumns, astToWhere, astToEntries } = require('../parse/ast2cqn')
+const { entriesStructureToEntityStructure } = require('./utils')
+
+module.exports = async (service, entityFQN, selection) => {
+  const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)
+
+  let queryBeforeUpdate = service.read(entityFQN)
+  queryBeforeUpdate.columns(astToColumns(selection.selectionSet.selections))
+
+  if (filter) {
+    queryBeforeUpdate.where(astToWhere(filter))
+  }
+
+  const resultBeforeUpdate = await service.tx(tx => tx.run(queryBeforeUpdate))
+
+  let query = service.update(entityFQN)
+
+  if (filter) {
+    query.where(astToWhere(filter))
+  }
+
+  const input = getArgumentByName(selection.arguments, ARGUMENT.INPUT)
+  const entries = entriesStructureToEntityStructure(service, entityFQN, astToEntries(input))
+  query.with(entries)
+
+  const result = await service.tx(tx => tx.run(query))
+
+  // Merge selected fields with updated data
+  return resultBeforeUpdate.map(original => ({ ...original, ...result }))
+}

package/libx/gql/resolvers/crud/utils/index.js

@@ -0,0 +1,36 @@
+const getEntityNameWithoutServicePrefix = (service, entityFQN) => entityFQN.replace(`${service.name}.`, '')
+
+const getEntityByFQN = (service, entityFQN) => service.entities[getEntityNameWithoutServicePrefix(service, entityFQN)]
+
+const objectStructureToEntityStructure = (service, entityFQN, entry) => {
+  const entity = getEntityByFQN(service, entityFQN)
+  for (const [k, v] of Object.entries(entry)) {
+    const element = entity.elements[k]
+    if (element.isComposition || element.isAssociation) {
+      if (Array.isArray(v)) {
+        if (element.is2one) {
+          entry[k] = v[0]
+        }
+      } else if (typeof v === 'object') {
+        if (element.is2many) {
+          entry[k] = [v]
+        }
+      }
+      entriesStructureToEntityStructure(service, element.target, v)
+    }
+  }
+  return entry
+}
+
+const entriesStructureToEntityStructure = (service, entityFQN, entries) => {
+  if (Array.isArray(entries)) {
+    for (const entry of entries) {
+      objectStructureToEntityStructure(service, entityFQN, entry)
+    }
+  } else {
+    objectStructureToEntityStructure(service, entityFQN, entries)
+  }
+  return entries
+}
+
+module.exports = { entriesStructureToEntityStructure }

package/libx/gql/resolvers/field.js

@@ -0,0 +1,5 @@
+// The GraphQL.js defaultFieldResolver does not support returning aliased values that resolve to fields with aliases
+module.exports = (source, args, context, info) => {
+  const responseKey = info.fieldNodes[0].alias ? info.fieldNodes[0].alias.value : info.fieldName
+  return source[responseKey]
+}

package/libx/gql/resolvers/index.js

@@ -0,0 +1,7 @@
+const fieldResolver = require('./field')
+const createRootResolvers = require('./root')
+
+module.exports = {
+  fieldResolver,
+  createRootResolvers
+}

package/libx/gql/resolvers/mutation.js

@@ -0,0 +1,23 @@
+const cds = require('../../_runtime/cds')
+const LOG = cds.log('graphql')
+
+const { MUTATION_PREFIX } = require('../constants/adapter')
+const { cdsName } = require('../utils')
+const { executeCreate, executeUpdate, executeDelete } = require('./crud')
+
+const GQL_MUTATION_REGEX = new RegExp(`^(${Object.values(MUTATION_PREFIX).join('|')})_(.+)$`)
+
+const actionToExecuteFunction = {
+  [MUTATION_PREFIX.CREATE]: executeCreate,
+  [MUTATION_PREFIX.UPDATE]: executeUpdate,
+  [MUTATION_PREFIX.DELETE]: executeDelete
+}
+
+module.exports = async (service, gqlName, field) => {
+  const { 1: mutationAction, 2: gqlNameWithoutAction } = gqlName.match(GQL_MUTATION_REGEX)
+  const entityFQN = `${service.name}.${cdsName(gqlNameWithoutAction)}`
+
+  LOG.log(`mutation on ${entityFQN}`)
+
+  return await actionToExecuteFunction[mutationAction](service, entityFQN, field)
+}

package/libx/gql/resolvers/parse/ast/enrich.js

@@ -0,0 +1,51 @@
+const { isVariable, isListValue, isObjectValue } = require('../utils')
+const fragmentSpreadSelections = require('./fragment')
+const substituteVariable = require('./variable')
+const removeMetaFieldsFromSelections = require('./meta')
+
+const traverseObjectValue = (info, objectValue) =>
+  objectValue.fields.map(field => traverseArgumentOrObjectField(info, field))
+
+const traverseListValue = (info, listValue) => {
+  for (let i = 0; i < listValue.values.length; i++) {
+    const value = listValue.values[i]
+    if (isVariable(value)) {
+      listValue.values[i] = substituteVariable(info, value)
+    } else if (isObjectValue(value)) {
+      traverseObjectValue(info, value)
+    }
+  }
+}
+
+const traverseArgumentOrObjectField = (info, argumentOrObjectField) => {
+  const value = argumentOrObjectField.value
+  if (isVariable(value)) {
+    argumentOrObjectField.value = substituteVariable(info, value)
+  } else if (isListValue(value)) {
+    traverseListValue(info, value)
+  } else if (isObjectValue(value)) {
+    traverseObjectValue(info, value)
+  }
+}
+
+const traverseSelectionSet = (info, selectionSet) => {
+  selectionSet.selections = fragmentSpreadSelections(info, selectionSet.selections)
+  selectionSet.selections = removeMetaFieldsFromSelections(selectionSet.selections)
+  selectionSet.selections.map(field => traverseField(info, field))
+}
+
+const traverseField = (info, field) => {
+  if (field.selectionSet) {
+    traverseSelectionSet(info, field.selectionSet)
+  }
+
+  field.arguments.map(arg => traverseArgumentOrObjectField(info, arg))
+}
+
+const traverseFieldNodes = (info, fieldNodes) => fieldNodes.map(fieldNode => traverseField(info, fieldNode))
+
+module.exports = info => {
+  const deepClonedFieldNodes = JSON.parse(JSON.stringify(info.fieldNodes))
+  traverseFieldNodes(info, deepClonedFieldNodes)
+  return deepClonedFieldNodes
+}

package/libx/gql/resolvers/parse/ast/fragment.js

@@ -0,0 +1,11 @@
+const { isFragmentSpread } = require('../utils')
+
+const getFragmentDefinitionForFragmentSpread = (info, fragmentSpread) => info.fragments[fragmentSpread.name.value]
+
+const substituteFragment = (info, fragmentSpread) =>
+  getFragmentDefinitionForFragmentSpread(info, fragmentSpread).selectionSet.selections
+
+const fragmentSpreadSelections = (info, selections) =>
+  selections.flatMap(selection => (isFragmentSpread(selection) ? substituteFragment(info, selection) : [selection]))
+
+module.exports = fragmentSpreadSelections

package/libx/gql/resolvers/parse/ast/fromObject.js

@@ -0,0 +1,39 @@
+const { AST_NODE_KIND } = require('../../../constants/graphql')
+
+const valueToGenericScalarValue = value => ({
+  kind: 'GenericScalarValue',
+  value
+})
+
+const keyToName = key => ({
+  kind: AST_NODE_KIND.Name,
+  value: key
+})
+
+const keyValueToObjectField = (k, v) => ({
+  kind: AST_NODE_KIND.ObjectField,
+  name: keyToName(k),
+  value: variableToValue(v)
+})
+
+const objectToObjectValue = object => ({
+  kind: AST_NODE_KIND.ObjectValue,
+  fields: Object.entries(object).map(([k, v]) => keyValueToObjectField(k, v))
+})
+
+const arrayToListValue = array => ({
+  kind: AST_NODE_KIND.ListValue,
+  values: array.map(a => objectToObjectValue(a))
+})
+
+const variableToValue = variable => {
+  if (Array.isArray(variable)) {
+    return arrayToListValue(variable)
+  } else if (typeof variable === 'object') {
+    return objectToObjectValue(variable)
+  } else {
+    return valueToGenericScalarValue(variable)
+  }
+}
+
+module.exports = variableValue => variableToValue(variableValue)

package/libx/gql/resolvers/parse/ast/index.js

@@ -0,0 +1,3 @@
+const enrichAST = require('./enrich')
+
+module.exports = { enrichAST }

package/libx/gql/resolvers/parse/ast/meta.js

@@ -0,0 +1,4 @@
+const removeMetaFieldsFromSelections = selections =>
+  selections.filter(selection => selection.name.value !== '__typename')
+
+module.exports = removeMetaFieldsFromSelections

package/libx/gql/resolvers/parse/ast/variable.js

@@ -0,0 +1,7 @@
+const objectToAST = require('./fromObject')
+
+const getVariableValueForVariable = (info, variable) => info.variableValues[variable.name.value]
+
+const substituteVariable = (info, variable) => objectToAST(getVariableValueForVariable(info, variable))
+
+module.exports = substituteVariable

package/libx/gql/resolvers/parse/ast2cqn/columns.js

@@ -0,0 +1,42 @@
+const { getArgumentByName } = require('./utils')
+const astToWhere = require('./where')
+const astToOrderBy = require('./orderBy')
+const astToLimit = require('./limit')
+const { ARGUMENT } = require('../../../constants/adapter')
+
+const astToColumns = selections => {
+  let columns = []
+
+  for (const selection of selections) {
+    const column = { ref: [selection.name.value] }
+    if (selection.alias) {
+      column.as = selection.alias.value
+    }
+
+    if (selection.selectionSet && selection.selectionSet.selections) {
+      column.expand = astToColumns(selection.selectionSet.selections)
+    }
+
+    const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)
+    if (filter) {
+      column.where = astToWhere(filter).xpr
+    }
+
+    const orderBy = getArgumentByName(selection.arguments, ARGUMENT.ORDER_BY)
+    if (orderBy) {
+      column.orderBy = astToOrderBy(orderBy)
+    }
+
+    const top = getArgumentByName(selection.arguments, ARGUMENT.TOP)
+    const skip = getArgumentByName(selection.arguments, ARGUMENT.SKIP)
+    if (top) {
+      column.limit = astToLimit(top, skip)
+    }
+
+    columns.push(column)
+  }
+
+  return columns
+}
+
+module.exports = astToColumns

package/libx/gql/resolvers/parse/ast2cqn/entries.js

@@ -0,0 +1,31 @@
+const { isListValue, isObjectValue } = require('../utils')
+
+const parseObjectField = objectField => {
+  const value = objectField.value
+  if (isListValue(value)) {
+    return parseListValue(value)
+  } else if (isObjectValue(value)) {
+    return parseObjectValue(value)
+  } else {
+    return value.value
+  }
+}
+
+const parseObjectValue = objectValue =>
+  objectValue.fields.reduce((entry, objectField) => {
+    entry[objectField.name.value] = parseObjectField(objectField)
+    return entry
+  }, {})
+
+const parseListValue = listValue => listValue.values.map(value => parseObjectValue(value))
+
+const astToEntries = inputArg => {
+  const value = inputArg.value
+  if (isListValue(value)) {
+    return parseListValue(value)
+  } else if (isObjectValue(value)) {
+    return parseObjectValue(value)
+  }
+}
+
+module.exports = astToEntries

package/libx/gql/resolvers/parse/ast2cqn/index.js

@@ -0,0 +1,8 @@
+const { getArgumentByName } = require('./utils')
+const astToColumns = require('./columns')
+const astToWhere = require('./where')
+const astToOrderBy = require('./orderBy')
+const astToLimit = require('./limit')
+const astToEntries = require('./entries')
+
+module.exports = { getArgumentByName, astToColumns, astToWhere, astToOrderBy, astToLimit, astToEntries }

package/libx/gql/resolvers/parse/ast2cqn/limit.js

@@ -0,0 +1,6 @@
+const astToLimit = (topArg, skipArg) => ({
+  rows: { val: topArg.value.value },
+  offset: { val: (skipArg && skipArg.value.value) || 0 }
+})
+
+module.exports = astToLimit

package/libx/gql/resolvers/parse/ast2cqn/orderBy.js

@@ -0,0 +1,24 @@
+const { isListValue, isObjectValue } = require('../utils')
+
+const objectFieldToOrderBy = objectField => ({
+  ref: [objectField.name.value],
+  sort: objectField.value.value
+})
+
+const parseObjectValue = objectValue => {
+  // OrderBy objects are supposed to contain only a single field
+  return objectFieldToOrderBy(objectValue.fields[0])
+}
+
+const parseListValue = listValue => listValue.values.map(value => parseObjectValue(value))
+
+const astToOrderBy = orderByArg => {
+  const value = orderByArg.value
+  if (isListValue(value)) {
+    return parseListValue(value)
+  } else if (isObjectValue(value)) {
+    return [parseObjectValue(value)]
+  }
+}
+
+module.exports = astToOrderBy

package/libx/gql/resolvers/parse/ast2cqn/utils/index.js

@@ -0,0 +1,3 @@
+const getArgumentByName = (args, name) => args.find(arg => arg.name.value === name)
+
+module.exports = { getArgumentByName }

package/libx/gql/resolvers/parse/ast2cqn/where.js

@@ -0,0 +1,70 @@
+const { STRING_MATCH_OPERATOR } = require('../../../constants/adapter')
+const { GQL_TO_CDS_QL_OPERATOR, GQL_TO_CDS_STRING_MATCH_OPERATOR } = require('../../../constants/cds')
+const { isListValue, isObjectValue } = require('../utils')
+
+const stringMatchOperatorToLikeString = (operator, string) => {
+  switch (operator) {
+    case STRING_MATCH_OPERATOR.STARTSWITH:
+      return `${string}%`
+    case STRING_MATCH_OPERATOR.ENDSWITH:
+      return `%${string}`
+    case STRING_MATCH_OPERATOR.CONTAINS:
+      return `%${string}%`
+  }
+}
+
+const arrayInsertBetweenFlat = (array, element) => {
+  return [...array].flatMap((e, index) => (index < array.length - 1 ? [e, element] : [e])).flat()
+}
+
+const joinedXprFrom_xprs = (_xprs, operator) => {
+  return { xpr: arrayInsertBetweenFlat(_xprs, operator) }
+}
+
+const gqlOperatorToCdsOperator = gqlOperator =>
+  GQL_TO_CDS_QL_OPERATOR[gqlOperator] || GQL_TO_CDS_STRING_MATCH_OPERATOR[gqlOperator]
+
+const gqlValueToCdsValue = (cdsOperator, gqlOperator, gqlValue) =>
+  cdsOperator === 'like' ? stringMatchOperatorToLikeString(gqlOperator, gqlValue) : gqlValue
+
+const objectFieldTo_xpr = (objectField, columnName) => {
+  const gqlOperator = objectField.name.value
+  const cdsOperator = gqlOperatorToCdsOperator(gqlOperator)
+  const gqlValue = objectField.value.value
+  const cdsValue = gqlValueToCdsValue(cdsOperator, gqlOperator, gqlValue)
+
+  return [{ ref: [columnName] }, cdsOperator, { val: cdsValue }]
+}
+
+const parseObjectField = (objectField, columnName) => {
+  const value = objectField.value
+  const name = objectField.name.value
+  if (isListValue(value)) {
+    return parseListValue(value, name)
+  } else if (isObjectValue(value)) {
+    return parseObjectValue(value, name)
+  } else {
+    return objectFieldTo_xpr(objectField, columnName)
+  }
+}
+
+const parseObjectValue = (objectValue, columnName) => {
+  const _xprs = objectValue.fields.map(field => parseObjectField(field, columnName))
+  return _xprs.length === 1 ? _xprs[0] : joinedXprFrom_xprs(_xprs, 'and')
+}
+
+const parseListValue = (listValue, columnName) => {
+  const _xprs = listValue.values.map(value => parseObjectValue(value, columnName))
+  return _xprs.length === 1 ? _xprs[0] : joinedXprFrom_xprs(_xprs, 'or')
+}
+
+const astToWhere = filterArg => {
+  const value = filterArg.value
+  if (isListValue(value)) {
+    return parseListValue(value)
+  } else if (isObjectValue(value)) {
+    return parseObjectValue(value)
+  }
+}
+
+module.exports = astToWhere

package/libx/gql/resolvers/parse/utils/index.js

@@ -0,0 +1,8 @@
+const { AST_NODE_KIND } = require('../../../constants/graphql')
+
+const isFragmentSpread = value => value.kind === AST_NODE_KIND.FragmentSpread
+const isListValue = value => value.kind === AST_NODE_KIND.ListValue
+const isObjectValue = value => value.kind === AST_NODE_KIND.ObjectValue
+const isVariable = value => value.kind === AST_NODE_KIND.Variable
+
+module.exports = { isFragmentSpread, isListValue, isObjectValue, isVariable }

package/libx/gql/resolvers/query.js

@@ -0,0 +1,13 @@
+const cds = require('../../_runtime/cds')
+const LOG = cds.log('graphql')
+
+const { cdsName } = require('../utils')
+const { executeRead } = require('./crud')
+
+module.exports = async (service, gqlName, field) => {
+  const entityFQN = `${service.name}.${cdsName(gqlName)}`
+
+  LOG.log(`query on ${entityFQN}`)
+
+  return await executeRead(service, entityFQN, field)
+}

package/libx/gql/resolvers/root.js

@@ -0,0 +1,34 @@
+const { gqlName } = require('../utils')
+const resolveQuery = require('./query')
+const resolveMutation = require('./mutation')
+const { enrichAST } = require('./parse/ast')
+
+const wrapResolver = (service, resolver) => (root, args, context, info) => {
+  const response = {}
+
+  const enrichedFieldNodes = enrichAST(info)
+
+  for (const fieldNode of enrichedFieldNodes) {
+    for (const field of fieldNode.selectionSet.selections) {
+      const gqlName = field.name.value
+      const responseKey = field.alias ? field.alias.value : gqlName
+
+      response[responseKey] = resolver(service, gqlName, field)
+    }
+  }
+
+  return response
+}
+
+module.exports = services => {
+  const Query = {}
+  const Mutation = {}
+
+  for (const service of services) {
+    const gqlServiceName = gqlName(service.name)
+    Query[gqlServiceName] = wrapResolver(service, resolveQuery)
+    Mutation[gqlServiceName] = wrapResolver(service, resolveMutation)
+  }
+
+  return { Query, Mutation }
+}

package/libx/gql/schema/generate.js

@@ -0,0 +1,18 @@
+const { typeDefMapToMutationStringArray } = require('./mutation')
+const { typeDefMapToQueryStringArray } = require('./query')
+const { servicesToTypeDefMap } = require('./typeDefMap')
+
+const typeDefMapToSchemaString = typeDefs => {
+  let schema = []
+
+  schema.push(...typeDefMapToQueryStringArray(typeDefs))
+
+  schema.push(...typeDefMapToMutationStringArray(typeDefs))
+
+  return schema.join('\n')
+}
+
+module.exports = services => {
+  const typeDefMap = servicesToTypeDefMap(services)
+  return typeDefMapToSchemaString(typeDefMap)
+}

package/libx/gql/schema/index.js

@@ -0,0 +1,5 @@
+const generate = require('./generate')
+
+module.exports = {
+  generate
+}

package/libx/gql/schema/mutation.js

@@ -0,0 +1,76 @@
+const { ARGUMENT, MUTATION_PREFIX, INPUT_OBJECT_SUFFIX } = require('../constants/adapter')
+const { GQL_ROOT, GQL_KEYWORDS, SCALAR_TYPES } = require('../constants/graphql')
+const { generateSchemaObject, typeToArgumentType, isTypeScalar, appendSuffixToType } = require('./utils')
+
+const typeDefMapToMutationStringArray = typeDefs => {
+  let schema = []
+
+  // Create root mutation (containing services)
+  schema.push(
+    ...generateSchemaObject(
+      GQL_KEYWORDS.TYPE,
+      GQL_ROOT.MUTATION,
+      Object.keys(typeDefs).reduce((fields, serviceName) => {
+        fields[serviceName] = `${serviceName}_${INPUT_OBJECT_SUFFIX.INPUT}`
+        return fields
+      }, {})
+    )
+  )
+
+  // Create types for mutations from services (each containing entities)
+  for (const [serviceName, entities] of Object.entries(typeDefs)) {
+    const fields = {}
+    for (const entityName of Object.keys(entities)) {
+      const entityNameWithoutServicePrefix = entityName.replace(`${serviceName}_`, '')
+
+      const createMutationName = `${MUTATION_PREFIX.CREATE}_${entityNameWithoutServicePrefix}`
+      const createMutationArgs = `(${ARGUMENT.INPUT}: [${entityName}_${INPUT_OBJECT_SUFFIX.CREATE}]!)`
+      fields[`${createMutationName}${createMutationArgs}`] = `[${entityName}]`
+
+      const updateMutationName = `${MUTATION_PREFIX.UPDATE}_${entityNameWithoutServicePrefix}`
+      const updateMutationArgs = `(${ARGUMENT.FILTER}: ${typeToArgumentType(entityName, ARGUMENT.FILTER)}, ${
+        ARGUMENT.INPUT
+      }: ${entityName}_${INPUT_OBJECT_SUFFIX.UPDATE}!)`
+      fields[`${updateMutationName}${updateMutationArgs}`] = `[${entityName}]`
+
+      const deleteMutationName = `${MUTATION_PREFIX.DELETE}_${entityNameWithoutServicePrefix}`
+      const deleteMutationArgs = `(${ARGUMENT.FILTER}: ${typeToArgumentType(entityName, ARGUMENT.FILTER)})`
+      fields[`${deleteMutationName}${deleteMutationArgs}`] = SCALAR_TYPES.INT
+    }
+    schema.push(...generateSchemaObject(GQL_KEYWORDS.TYPE, `${serviceName}_${INPUT_OBJECT_SUFFIX.INPUT}`, fields))
+  }
+
+  // Create input types for create mutations from entities (each containing elements)
+  for (const entities of Object.values(typeDefs)) {
+    for (const [entityName, elements] of Object.entries(entities)) {
+      const fields = {}
+      for (const [elementName, elementType] of Object.entries(elements)) {
+        if (isTypeScalar(elementType)) {
+          fields[elementName] = elementType
+        } else {
+          fields[elementName] = appendSuffixToType(elementType, INPUT_OBJECT_SUFFIX.CREATE)
+        }
+      }
+      schema.push(...generateSchemaObject(GQL_KEYWORDS.INPUT, `${entityName}_${INPUT_OBJECT_SUFFIX.CREATE}`, fields))
+    }
+  }
+
+  // Create input types for update mutations from entities (each containing elements)
+  for (const entities of Object.values(typeDefs)) {
+    for (const [entityName, elements] of Object.entries(entities)) {
+      const fields = {}
+      for (const [elementName, elementType] of Object.entries(elements)) {
+        if (isTypeScalar(elementType)) {
+          fields[elementName] = elementType
+        } else {
+          fields[elementName] = appendSuffixToType(elementType, INPUT_OBJECT_SUFFIX.UPDATE)
+        }
+      }
+      schema.push(...generateSchemaObject(GQL_KEYWORDS.INPUT, `${entityName}_${INPUT_OBJECT_SUFFIX.UPDATE}`, fields))
+    }
+  }
+
+  return schema
+}
+
+module.exports = { typeDefMapToMutationStringArray }