@sap/cds 5.5.5 → 5.6.0

package/libx/gql/constants/adapter.js

@@ -0,0 +1,69 @@
+const { SCALAR_TYPES } = require('./graphql')
+
+// TODO own scalar types
+const CDS_TO_GRAPHQL_TYPES = {
+  'cds.Binary': SCALAR_TYPES.STRING,
+  'cds.Boolean': SCALAR_TYPES.BOOLEAN,
+  'cds.Date': SCALAR_TYPES.STRING,
+  'cds.DateTime': SCALAR_TYPES.STRING,
+  'cds.Decimal': SCALAR_TYPES.FLOAT,
+  'cds.DecimalFloat': SCALAR_TYPES.FLOAT,
+  'cds.Double': SCALAR_TYPES.STRING,
+  'cds.Integer': SCALAR_TYPES.INT,
+  'cds.Integer64': SCALAR_TYPES.STRING,
+  'cds.LargeBinary': SCALAR_TYPES.STRING,
+  'cds.LargeString': SCALAR_TYPES.STRING,
+  'cds.String': SCALAR_TYPES.STRING,
+  'cds.Time': SCALAR_TYPES.STRING,
+  'cds.Timestamp': SCALAR_TYPES.STRING,
+  'cds.UUID': SCALAR_TYPES.ID
+}
+
+const ARGUMENT = {
+  INPUT: 'input',
+  FILTER: 'filter',
+  ORDER_BY: 'orderBy',
+  TOP: 'top',
+  SKIP: 'skip'
+}
+
+const HELPER_TYPES = {
+  SORT_DIRECTION: 'SortDirection'
+}
+
+const EQUALITY_OPERATOR = {
+  EQ: 'eq',
+  NE: 'ne',
+  GT: 'gt',
+  GE: 'ge',
+  LE: 'le',
+  LT: 'lt'
+}
+
+const STRING_MATCH_OPERATOR = {
+  STARTSWITH: 'startswith',
+  ENDSWITH: 'endswith',
+  CONTAINS: 'contains'
+}
+
+const MUTATION_PREFIX = {
+  CREATE: 'create',
+  UPDATE: 'update',
+  DELETE: 'delete'
+}
+
+const INPUT_OBJECT_SUFFIX = {
+  INPUT: 'input',
+  CREATE: 'C',
+  UPDATE: 'U'
+}
+
+module.exports = {
+  CDS_TO_GRAPHQL_TYPES,
+  ARGUMENT,
+  HELPER_TYPES,
+  EQUALITY_OPERATOR,
+  STRING_MATCH_OPERATOR,
+  MUTATION_PREFIX,
+  INPUT_OBJECT_SUFFIX
+}

package/libx/gql/constants/cds.js

@@ -0,0 +1,18 @@
+const { EQUALITY_OPERATOR, STRING_MATCH_OPERATOR } = require('./adapter')
+
+const GQL_TO_CDS_QL_OPERATOR = {
+  [EQUALITY_OPERATOR.EQ]: '=',
+  [EQUALITY_OPERATOR.NE]: '<>',
+  [EQUALITY_OPERATOR.GT]: '>',
+  [EQUALITY_OPERATOR.GE]: '>=',
+  [EQUALITY_OPERATOR.LE]: '<=',
+  [EQUALITY_OPERATOR.LT]: '<'
+}
+
+const GQL_TO_CDS_STRING_MATCH_OPERATOR = {
+  [STRING_MATCH_OPERATOR.STARTSWITH]: 'like',
+  [STRING_MATCH_OPERATOR.ENDSWITH]: 'like',
+  [STRING_MATCH_OPERATOR.CONTAINS]: 'like'
+}
+
+module.exports = { GQL_TO_CDS_QL_OPERATOR, GQL_TO_CDS_STRING_MATCH_OPERATOR }

package/libx/gql/constants/graphql.js

@@ -0,0 +1,33 @@
+const GQL_ROOT = {
+  QUERY: 'Query',
+  MUTATION: 'Mutation'
+}
+
+const GQL_KEYWORDS = {
+  TYPE: 'type',
+  ENUM: 'enum',
+  INPUT: 'input'
+}
+
+const SCALAR_TYPES = {
+  INT: 'Int',
+  FLOAT: 'Float',
+  STRING: 'String',
+  BOOLEAN: 'Boolean',
+  ID: 'ID'
+}
+
+// String starts with [ and ends with ]
+// Capture group captures in between brackets
+const GQL_LIST_REGEX = /^\[(.+)\]$/
+
+const AST_NODE_KIND = {
+  ListValue: 'ListValue',
+  ObjectValue: 'ObjectValue',
+  ObjectField: 'ObjectField',
+  FragmentSpread: 'FragmentSpread',
+  Variable: 'Variable',
+  Name: 'Name'
+}
+
+module.exports = { GQL_ROOT, GQL_KEYWORDS, SCALAR_TYPES, GQL_LIST_REGEX, AST_NODE_KIND }

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

@@ -0,0 +1,15 @@
+const { ARGUMENT } = require('../../constants/adapter')
+const { getArgumentByName, astToEntries } = require('../parse/ast2cqn')
+const { entriesStructureToEntityStructure } = require('./utils')
+
+module.exports = async (service, entityFQN, selection) => {
+  let query = service.create(entityFQN)
+
+  const input = getArgumentByName(selection.arguments, ARGUMENT.INPUT)
+  const entries = entriesStructureToEntityStructure(service, entityFQN, astToEntries(input))
+  query.entries(entries)
+
+  const result = await service.tx(tx => tx.run(query))
+
+  return Array.isArray(result) ? result : [result]
+}

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

@@ -0,0 +1,24 @@
+const { ARGUMENT } = require('../../constants/adapter')
+const { getArgumentByName, astToWhere } = require('../parse/ast2cqn')
+
+module.exports = async (service, entityFQN, selection) => {
+  let query = service.delete(entityFQN)
+
+  const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)
+  if (filter) {
+    query.where(astToWhere(filter))
+  }
+
+  let result
+  try {
+    result = await service.tx(tx => tx.run(query))
+  } catch (e) {
+    if (e.code === 404) {
+      result = 0
+    } else {
+      throw e
+    }
+  }
+
+  return result
+}

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)
+}