@sap/cds 5.5.5 → 5.6.3

package/libx/_runtime/remote/utils/client.js

@@ -1,8 +1,8 @@
 const cds = require('../../cds')
 const LOG = cds.log('remote')
-const cdsLocale = require('../../../../lib/req/locale.js')
 
-const generateQuery = require('../cqn2odata')
+const cdsLocale = require('../../../../lib/req/locale')
+
 const { convertV2ResponseData } = require('./dataConversion')
 
 let _cloudSdkCore
@@ -14,16 +14,38 @@ const PPPD = {
   DELETE: 1
 }
 
-const _executeHttpRequest = (...args) => {
-  if (!_cloudSdkCore) _cloudSdkCore = require('@sap-cloud-sdk/core')
+const KINDS_SUPPORTING_BATCH = { odata: 1, 'odata-v2': 1, 'odata-v4': 1 }
+
+const _executeHttpRequest = async ({ requestConfig, destination, destinationOptions, jwt }) => {
+  const { getDestination, executeHttpRequest } = cloudSdkCore()
 
-  const opts = args[1]
-  if (PPPD[opts.method] && cds.env.features.fetch_csrf) {
-    if (args.length === 3) args[2].fetchCsrfToken = true
-    else args.push({ fetchCsrfToken: true })
+  const destinationName = typeof destination === 'string' && destination
+  if (destinationName) {
+    destination = await getDestination(destinationName, resolveDestinationOptions(destinationOptions, jwt))
+  } else if (destination.forwardAuthToken) {
+    destination = {
+      ...destination,
+      headers: destination.headers ? { ...destination.headers } : {},
+      authentication: 'NoAuthentication'
+    }
+    delete destination.forwardAuthToken
+    if (jwt) {
+      destination.headers.authorization = `Bearer ${jwt}`
+    } else {
+      LOG._warn && LOG.warn('Missing JWT token for forwardAuthToken')
+    }
   }
 
-  return _cloudSdkCore.executeHttpRequest(...args)
+  let requestOptions
+  if (PPPD[requestConfig.method] && cds.env.features.fetch_csrf) {
+    requestOptions = { fetchCsrfToken: true }
+  }
+
+  return executeHttpRequest(destination, requestConfig, requestOptions)
+}
+
+const cloudSdkCore = function () {
+  return _cloudSdkCore || (_cloudSdkCore = require('@sap-cloud-sdk/core'))
 }
 
 const getDestination = (name, credentials) => {
@@ -34,6 +56,26 @@ const getDestination = (name, credentials) => {
   return { name, ...credentials }
 }
 
+/**
+ * @param {import('./client-types').DestinationOptions} [options]
+ * @param {string} [jwt]
+ * @returns {import('@sap-cloud-sdk/core').DestinationOptions}
+ */
+const resolveDestinationOptions = function (options, jwt) {
+  if (!options && !jwt) return undefined
+
+  const resolvedOptions = Object.assign({}, options || {})
+  resolvedOptions.userJwt = jwt
+
+  if (options && options.selectionStrategy) {
+    resolvedOptions.selectionStrategy = cloudSdkCore().DestinationSelectionStrategies[options.selectionStrategy]
+    if (!resolvedOptions.selectionStrategy)
+      throw new Error(`Unsupported destination selection strategy "${options.selectionStrategy}".`)
+  }
+
+  return resolvedOptions
+}
+
 const getKind = options => {
   const kind = (options.credentials && options.credentials.kind) || options.kind
   if (typeof kind === 'object') {
@@ -175,17 +217,19 @@ const _getSanitizedError = (e, reqOptions, suppressRemoteResponseBody) => {
   return e
 }
 
-const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppressRemoteResponseBody }) => {
-  const dest = typeof destination === 'string' ? { destinationName: destination, jwt } : destination
-
+// eslint-disable-next-line complexity
+const run = async (
+  requestConfig,
+  { destination, jwt, kind, resolvedTarget, suppressRemoteResponseBody, destinationOptions }
+) => {
   let response
   try {
-    response = await _executeHttpRequest(dest, reqOptions)
+    response = await _executeHttpRequest({ requestConfig, destination, destinationOptions, jwt })
   } catch (e) {
     // > axios received status >= 400 -> gateway error
     e.message = e.message ? 'Error during request to remote service: ' + e.message : 'Request to remote service failed.'
 
-    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
+    const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -198,15 +242,15 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppres
     response.headers['content-type'] &&
     response.headers['content-type'].includes('text/html') &&
     !(
-      reqOptions.headers.accept.includes('text/html') ||
-      reqOptions.headers.accept.includes('text/*') ||
-      reqOptions.headers.accept.includes('*/*')
+      requestConfig.headers.accept.includes('text/html') ||
+      requestConfig.headers.accept.includes('text/*') ||
+      requestConfig.headers.accept.includes('*/*')
     )
   ) {
     const e = new Error("Received content-type 'text/html' which is not part of accepted content types")
     e.response = response
 
-    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
+    const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -216,13 +260,38 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppres
     })
   }
 
+  // get result of $batch
+  // does only support read requests as of now
+  if (requestConfig._autoBatch) {
+    // response data splitted by empty lines
+    // 1. entry contains batch id and batch headers
+    // 2. entry contains request status code and request headers
+    // 3. entry contains data or error
+    const responseDataSplitted = response.data.split('\r\n\r\n')
+    // remove closing batch id
+    const [content] = responseDataSplitted[2].split('\r\n')
+    const contentJSON = JSON.parse(content)
+
+    if (responseDataSplitted[1].startsWith('HTTP/1.1 2')) {
+      response.data = contentJSON
+    }
+    if (responseDataSplitted[1].startsWith('HTTP/1.1 4') || responseDataSplitted[1].startsWith('HTTP/1.1 5')) {
+      contentJSON.message = contentJSON.message
+        ? 'Error during request to remote service: ' + contentJSON.message
+        : 'Request to remote service failed.'
+      const sanitizedError = _getSanitizedError(contentJSON, requestConfig)
+      LOG._warn && LOG.warn(sanitizedError)
+      throw Object.assign(new Error(contentJSON.message), { statusCode: 502, innererror: sanitizedError })
+    }
+  }
+
   if (kind === 'odata-v4') return _purgeODataV4(response.data)
-  if (kind === 'odata-v2') return _purgeODataV2(response.data, resolvedTarget, reqOptions.headers)
+  if (kind === 'odata-v2') return _purgeODataV2(response.data, resolvedTarget, requestConfig.headers)
   if (kind === 'odata') {
     if (typeof response.data !== 'object') return response.data
     // try to guess if we need to purge v2 or v4
     if (response.data.d) {
-      return _purgeODataV2(response.data, resolvedTarget, reqOptions.headers)
+      return _purgeODataV2(response.data, resolvedTarget, requestConfig.headers)
     }
     return _purgeODataV4(response.data)
   }
@@ -241,7 +310,7 @@ const getJwt = req => {
 }
 
 const _cqnToReqOptions = (query, kind, model) => {
-  const queryObject = generateQuery(query, kind, model)
+  const queryObject = cds.odata.urlify(query, { kind, model })
   return {
     method: queryObject.method,
     url: encodeURI(
@@ -312,14 +381,39 @@ const getReqOptions = (req, query, service) => {
   }
   reqOptions.url = formatPath(reqOptions.url)
 
+  // batch envelope if needed
+  if (
+    KINDS_SUPPORTING_BATCH[service.kind] &&
+    reqOptions.method === 'GET' &&
+    reqOptions.url.length > ((cds.env.remote && cds.env.remote.max_get_url_length) || 1028)
+  ) {
+    reqOptions._autoBatch = true
+    reqOptions.data = [
+      '--batch1',
+      'Content-Type: application/http',
+      'Content-Transfer-Encoding: binary',
+      '',
+      `${reqOptions.method} ${reqOptions.url.replace(/^\//, '')} HTTP/1.1`,
+      ...Object.keys(reqOptions.headers).map(k => `${k}: ${reqOptions.headers[k]}`),
+      '',
+      '',
+      '--batch1--',
+      ''
+    ].join('\r\n')
+    reqOptions.method = 'POST'
+    reqOptions.headers.accept = 'multipart/mixed'
+    reqOptions.headers['content-type'] = 'multipart/mixed; boundary=batch1'
+    reqOptions.url = '/$batch'
+  }
+
   if (service.path) reqOptions.url = `${encodeURI(service.path)}${reqOptions.url}`
 
   return reqOptions
 }
 
-const getAdditionalOptions = (req, destination, kind, resolvedTarget) => {
+const getAdditionalOptions = (req, destination, kind, resolvedTarget, destinationOptions) => {
   const jwt = getJwt(req)
-  const additionalOptions = { destination, kind, resolvedTarget }
+  const additionalOptions = { destination, kind, resolvedTarget, destinationOptions }
   if (jwt) additionalOptions.jwt = jwt
   return additionalOptions
 }

package/libx/_runtime/sqlite/Service.js

@@ -71,7 +71,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
      */
     // all others, i.e. CREATE, DROP table, ...
     this.on('*', function (req) {
-      return this._run(this.model, this.dbc, req.query || req.event, req)
+      return this._run(this.model, this.dbc, req.query || req.event, req, req.data)
     })
   }
 
@@ -189,7 +189,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
         log('DROP TABLE IF EXISTS ' + entity + ';')
       }
       log()
-      for (const each of createEntities) log(each + ';\n')
+      for (const each of createEntities) log(each + '\n')
       return
     }
 

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -1,10 +1,8 @@
-const { foreignKeyPropagations } = require('../common/utils/foreignKeyPropagations')
 const getError = require('../common/error')
 
 function _convertRefForAssocToOneManaged(element, refEntry) {
   const maybeManagedKey = refEntry.ref.join('_')
-  const _foreignKeyPropagations = foreignKeyPropagations(element)
-  if (_foreignKeyPropagations.filter(key => key.parentFieldName === maybeManagedKey)[0]) {
+  if (element._foreignKeys.find(key => key.parentElement && key.parentElement.name === maybeManagedKey)) {
     refEntry.ref = [maybeManagedKey]
   } else {
     throw getError(501, 'Path expressions in query options are not supported on SQLite')

package/libx/gql/GraphQLAdapter.js

@@ -0,0 +1,33 @@
+const cds = require('../_runtime/cds')
+
+const express = require('express')
+const { graphqlHTTP } = require('express-graphql')
+const { makeExecutableSchema } = require('@graphql-tools/schema')
+
+const { generate } = require('./schema')
+const { fieldResolver, createRootResolvers } = require('./resolvers')
+
+class GraphQLAdapter extends express.Router {
+  constructor(services, options) {
+    super()
+    const mergedOptions = { ...defaultOptions, ...options }
+
+    const path = mergedOptions.path
+    delete mergedOptions.path
+
+    const applicationServices = Object.values(services).filter(service => service instanceof cds.ApplicationService)
+
+    const typeDefs = generate(applicationServices)
+    const resolvers = createRootResolvers(applicationServices)
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    this.use(path, graphqlHTTP({ fieldResolver, schema, ...mergedOptions }))
+  }
+}
+
+const defaultOptions = {
+  path: '/graphql'
+}
+
+module.exports = GraphQLAdapter

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