@sap/cds 5.5.5 → 5.6.3

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 }

package/libx/gql/schema/query.js

@@ -0,0 +1,108 @@
+const { ARGUMENT, HELPER_TYPES, EQUALITY_OPERATOR, STRING_MATCH_OPERATOR } = require('../constants/adapter')
+const { GQL_ROOT, GQL_KEYWORDS, SCALAR_TYPES } = require('../constants/graphql')
+const {
+  generateSchemaObject,
+  typeToArgumentType,
+  generateArgumentsForType,
+  isTypeScalar,
+  typeWithoutListBrackets
+} = require('./utils')
+
+const generateScalarFilterTypes = () => Object.values(SCALAR_TYPES).flatMap(scalarType => fullFilter(scalarType))
+
+const fullFilter = type => {
+  const operations = Object.values(EQUALITY_OPERATOR)
+  if (type === SCALAR_TYPES.STRING) {
+    operations.push(...Object.values(STRING_MATCH_OPERATOR))
+  }
+  const entries = operations.reduce((acc, operation) => {
+    acc[operation] = type
+    return acc
+  }, {})
+  return generateSchemaObject(GQL_KEYWORDS.INPUT, `${type}_${ARGUMENT.FILTER}`, entries)
+}
+
+const typeDefMapToQueryStringArray = typeDefs => {
+  let schema = []
+
+  // Create root query (containing services)
+  schema.push(
+    ...generateSchemaObject(
+      GQL_KEYWORDS.TYPE,
+      GQL_ROOT.QUERY,
+      Object.keys(typeDefs).reduce((fields, serviceName) => {
+        fields[serviceName] = serviceName
+        return fields
+      }, {})
+    )
+  )
+
+  // Create types 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 argsString = generateArgumentsForType(entityName, [
+        ARGUMENT.FILTER,
+        ARGUMENT.ORDER_BY,
+        ARGUMENT.TOP,
+        ARGUMENT.SKIP
+      ])
+      fields[`${entityNameWithoutServicePrefix}${argsString}`] = `[${entityName}]`
+    }
+    schema.push(...generateSchemaObject(GQL_KEYWORDS.TYPE, serviceName, fields))
+  }
+
+  // Create types 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)) {
+        const argsString = generateArgumentsForType(elementType, [
+          ARGUMENT.FILTER,
+          ARGUMENT.ORDER_BY,
+          ARGUMENT.TOP,
+          ARGUMENT.SKIP
+        ])
+        fields[`${elementName}${argsString}`] = elementType
+      }
+      schema.push(...generateSchemaObject(GQL_KEYWORDS.TYPE, entityName, fields))
+    }
+  }
+
+  // Create filter input types for scalars
+  schema.push(...generateScalarFilterTypes())
+
+  // Create filter input types for entity types
+  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(typeWithoutListBrackets(elementType))) {
+          fields[elementName] = typeToArgumentType(elementType, ARGUMENT.FILTER)
+        }
+      }
+      if (Object.keys(fields).length > 0) {
+        schema.push(...generateSchemaObject(GQL_KEYWORDS.INPUT, `${entityName}_${ARGUMENT.FILTER}`, fields))
+      }
+    }
+  }
+
+  // Create sort direction enum types for order by
+  schema.push(...generateSchemaObject(GQL_KEYWORDS.ENUM, HELPER_TYPES.SORT_DIRECTION, ['asc', 'desc']))
+
+  // Create orderBy input types for entity types
+  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)) {
+        fields[elementName] = typeToArgumentType(elementType, ARGUMENT.ORDER_BY)
+      }
+      schema.push(...generateSchemaObject(GQL_KEYWORDS.INPUT, `${entityName}_${ARGUMENT.ORDER_BY}`, fields))
+    }
+  }
+
+  return schema
+}
+
+module.exports = { typeDefMapToQueryStringArray }

package/libx/gql/schema/typeDefMap.js

@@ -0,0 +1,45 @@
+const { CDS_TO_GRAPHQL_TYPES } = require('../constants/adapter')
+const { gqlName } = require('../utils')
+
+const servicesToTypeDefMap = services => {
+  const typeDefs = {}
+
+  // Create nested map of services, their entities, and their respective elements
+  for (const service of services) {
+    const serviceDefs = (typeDefs[gqlName(service.name)] = {})
+
+    const serviceNamePrefix = `${service.name}.`
+    const entitiesKV = Object.entries(service.model.definitions).filter(
+      // eslint-disable-next-line no-unused-vars
+      ([k, _]) => k.startsWith(serviceNamePrefix) && service.model.definitions[k].kind === 'entity'
+    )
+
+    // eslint-disable-next-line no-unused-vars
+    for (const [_, entity] of entitiesKV) {
+      const def = (serviceDefs[gqlName(entity.name)] = {})
+      for (const ele of Object.values(entity.elements)) {
+        if (ele.name.startsWith('up_') || ele.name === 'localized' || ele.name === 'texts') {
+          continue
+        } else if (ele.isAssociation || ele.isComposition) {
+          if (!ele.target.startsWith(serviceNamePrefix)) {
+            // TODO entities in other namespaces
+            continue
+          }
+          def[ele.name] = ele.is2one ? gqlName(ele.target) : `[${gqlName(ele.target)}]`
+        } else if (ele.elements) {
+          // TODO structured types
+          continue
+        } else {
+          if (CDS_TO_GRAPHQL_TYPES[ele.type]) {
+            def[ele.name] = CDS_TO_GRAPHQL_TYPES[ele.type]
+          }
+          // TODO aspects
+        }
+      }
+    }
+  }
+
+  return typeDefs
+}
+
+module.exports = { servicesToTypeDefMap }

package/libx/gql/schema/utils/index.js

@@ -0,0 +1,54 @@
+const { ARGUMENT, HELPER_TYPES } = require('../../constants/adapter')
+const { GQL_LIST_REGEX, SCALAR_TYPES } = require('../../constants/graphql')
+
+const generateSchemaObject = (type, name, fields) => {
+  const schema = [`${type} ${name} {`]
+  if (Array.isArray(fields)) {
+    schema.push(...fields.map(e => `  ${e}`))
+  } else {
+    schema.push(...Object.entries(fields).map(([k, v]) => `  ${k}: ${v}`))
+  }
+  schema.push('}', '')
+  return schema
+}
+
+const generateArgumentsForType = (type, args) =>
+  `(${args.map(action => `${action}: ${typeToArgumentType(type, action)}`).join(', ')})`
+
+const typeToArgumentType = (type, action) => {
+  switch (action) {
+    case ARGUMENT.FILTER:
+      return appendSuffixToType(type, ARGUMENT.FILTER, true)
+    case ARGUMENT.ORDER_BY:
+      return isTypeScalar(type) ? HELPER_TYPES.SORT_DIRECTION : appendSuffixToType(type, ARGUMENT.ORDER_BY, true)
+    case ARGUMENT.TOP:
+      return SCALAR_TYPES.INT
+    case ARGUMENT.SKIP:
+      return SCALAR_TYPES.INT
+  }
+}
+
+const isTypeScalar = type => Object.values(SCALAR_TYPES).includes(type)
+
+const isTypeList = type => type.match(GQL_LIST_REGEX)
+
+// Type without list brackets even if type isn't a list
+const typeWithoutListBrackets = type => type.replace(GQL_LIST_REGEX, '$1')
+
+const appendSuffixToType = (type, suffix, forceToList) => {
+  if (isTypeList(type) || forceToList) {
+    return `[${typeWithoutListBrackets(type)}_${suffix}]`
+  } else {
+    return `${type}_${suffix}`
+  }
+}
+
+module.exports = {
+  generateSchemaObject,
+  generateArgumentsForType,
+  typeToArgumentType,
+  isTypeScalar,
+  isTypeList,
+  typeWithoutListBrackets,
+  appendSuffixToType
+}

package/libx/gql/utils/index.js

@@ -0,0 +1,12 @@
+const cdsName = gqlName => {
+  return gqlName.replace(/_/g, '.')
+}
+
+const gqlName = cdsName => {
+  return cdsName.replace(/\./g, '_')
+}
+
+module.exports = {
+  cdsName,
+  gqlName
+}