@sap/cds 5.5.5 → 5.6.0

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

package/libx/{_runtime/odata/cqn2odata.js → odata/cqn2odata/index.js}

@@ -1,3 +1,5 @@
+const { formatVal } = require('../utils')
+
 const OPERATORS = {
   '=': 'eq',
   '!=': 'ne',
@@ -10,23 +12,13 @@ const OPERATORS = {
 
 const LAMBDA_VARIABLE = 'd'
 
-const getSafeNumber = str => {
-  const n = Number(str)
-  return Number.isSafeInteger(n) || String(n) === str ? n : str
-}
-
 const needArrayProps = Object.fromEntries(
-  ['where', 'search', 'xpr', 'columns', 'expand', 'orderBy', 'ref', 'args'].map(propName => [
+  ['where', 'search', 'xpr', 'columns', 'orderBy', 'ref', 'args'].map(propName => [
     propName,
-    cur =>
-      (Array.isArray(cur) && (cur.length !== 0 || propName === 'expand' || propName === 'ref')) ||
-      (propName === 'expand' && cur === '*')
+    cur => Array.isArray(cur) && (cur.length !== 0 || propName === 'expand' || propName === 'ref')
   ])
 )
 
-const V4UUIDREGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-const isV4UUID = val => V4UUIDREGEXP.test(val)
-
 const validators = {
   SELECT: SELECT => SELECT && SELECT.from,
   INSERT: INSERT => {
@@ -50,63 +42,13 @@ const validators = {
   func: func => typeof func === 'string',
   one: count => typeof count === 'boolean',
   as: any => typeof any === 'string',
+  expand: any => any === '*' || Array.isArray(any),
   ...needArrayProps
 }
 
 // strip service & namespace prefixes
 const _entityUrl = path => path.match(/^(\w*\.)*(.*)$/)[2]
 
-const formatVal = (val, element, csnTarget, kind) => {
-  if (val === null || val === 'null') return 'null'
-  if (typeof val === 'boolean') return val
-  if (typeof val === 'number') return getSafeNumber(val)
-  if (!csnTarget && typeof val === 'string' && isV4UUID(val)) return kind === 'odata-v2' ? `guid'${val}'` : val
-
-  const csnElement = (csnTarget && csnTarget.elements && csnTarget.elements[element]) || { type: undefined }
-  return kind === 'odata-v2' ? _odataV2Val(val, csnElement.type) : _val(val, csnElement.type)
-}
-
-const _isTimestamp = val =>
-  /^\d+-\d\d-\d\d(T\d\d:\d\d(:\d\d(\.\d+)?)?(Z|([+-]{1}\d\d:\d\d))?)?$/.test(val) && !isNaN(Date.parse(val))
-
-const _odataV2Val = (val, type) => {
-  switch (type) {
-    case 'cds.Binary':
-    case 'cds.LargeBinary':
-      return `binary'${val}'`
-    case 'cds.Date':
-    case 'cds.DateTime':
-      return `datetime'${val}'`
-    case 'cds.Time':
-      // eslint-disable-next-line no-case-declarations
-      const [hh, mm, ss] = val.split(':')
-      return `time'PT${hh}H${mm}M${ss}S'`
-    case 'cds.Timestamp':
-      return `datetimeoffset'${val}'`
-    case 'cds.UUID':
-      return `guid'${val}'`
-    default:
-      return `'${val}'`
-  }
-}
-
-const _val = (val, type) => {
-  switch (type) {
-    case 'cds.Decimal':
-    case 'cds.Integer64':
-      return getSafeNumber(val)
-    case 'cds.Boolean':
-    case 'cds.DateTime':
-    case 'cds.Date':
-    case 'cds.Timestamp':
-    case 'cds.Time':
-    case 'cds.UUID':
-      return val
-    default:
-      return _isTimestamp(val) ? val : `'${val}'`
-  }
-}
-
 function getProp(obj, propName) {
   const validate = validators[propName]
   const isValid = validate && validate(obj[propName])
@@ -166,13 +108,25 @@ const _in = (column, /* in */ collection, target, kind, isLambda) => {
   }
 }
 
+const _odataV2Func = (func, args) => {
+  switch (func) {
+    case 'contains':
+      // this doesn't support the contains signature with two collections as args, introduced in odata v4.01
+      return `substringof(${_args([args[1], args[0]])})`
+    default:
+      return `${func}(${_args(args)})`
+  }
+}
+
 const _format = (cur, element, target, kind, isLambda) => {
   if (typeof cur !== 'object') return formatVal(cur, element, target, kind)
   if (hasValidProps(cur, 'ref')) return isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref.join('/')
   if (hasValidProps(cur, 'val')) return formatVal(cur.val, element, target, kind)
   if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
   // REVISIT: How to detect the types for all functions?
-  if (hasValidProps(cur, 'func', 'args')) return `${cur.func}(${_args(cur.args)})`
+  if (hasValidProps(cur, 'func', 'args')) {
+    return kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args)})`
+  }
 }
 
 const _isLambda = (cur, next) => {
@@ -328,62 +282,48 @@ const _parseColumnsV2 = (columns, prefix = []) => {
   return { select, expand }
 }
 
-const _parseColumns = (columns, options) => {
-  const isExpand = options.expand
+const _parseColumns = columns => {
   const select = []
   const expand = []
 
-  if (columns === '*') {
-    return { select, expand }
-  }
-
-  const isSelectAll = select =>
-    select.length === 1 && (select[0] === '*' || (select[0].ref && select[0].ref[0] === '*'))
-
   for (const column of columns) {
     if (hasValidProps(column, 'ref')) {
-      const refName = column.ref.join('/')
-      let refNameWithOptions = refName
-
+      let refName = column.ref.join('/')
       if (hasValidProps(column, 'expand')) {
+        // REVISIT: incomplete, see test Foo?$expand=invoices($count=true;$expand=item($search="some"))
+        if (!columns.some(c => !c.expand)) select.push(refName)
         const curOptions = getOptions(column).join(';')
-        refNameWithOptions += curOptions ? `(${curOptions})` : ''
-        expand.push(refNameWithOptions)
-        if (!isSelectAll(select) && !isExpand) select.push(refName)
+        refName += curOptions ? `(${curOptions})` : ''
+        expand.push(refName)
         // REVISIT: expand to one & limit in options
-        // > const expanded = $expand(column.expand)
-        // > expand.push(expanded ? `${refNameWithOptions}(${expanded})` : ref)
+        // > const expanded = $expand(col.expand)
+        // > expand.push(expanded ? `${ref}(${expanded})` : ref)
         // see xtest('READ with expand'... in custom handler test
       } else {
-        select.push(refNameWithOptions)
+        select.push(refName)
       }
+    } else if (hasValidProps(column, 'expand') && column.expand === '*') {
+      expand.push('*')
     }
-
     if (column === '*') {
       select.push(column)
     }
   }
-
-  // omit $select query option if it only contains '*'
-  if (isSelectAll(select)) {
+  // omit '$select' option if contains only '*'
+  if (select.length === 1 && (select[0] === '*' || (select[0].ref && select[0].ref[0] === '*'))) {
     select.pop()
   }
-
-  const uniqueSelect = [...new Set(select)]
-  return { select: uniqueSelect, expand }
+  return { select, expand }
 }
 
-function $select(columns, kind, separator = '&', isExpand = false) {
-  const { select, expand } =
-    kind === 'odata-v2' ? _parseColumnsV2(columns) : _parseColumns(columns, { expand: isExpand })
-
+function $select(columns, kind, separator = '&') {
+  const { select, expand } = kind === 'odata-v2' ? _parseColumnsV2(columns) : _parseColumns(columns)
   const res = []
   if (expand.length) res.unshift('$expand=' + expand.join(','))
   if (select.length) res.unshift('$select=' + select.join(','))
   return res.join(separator)
 }
-
-const $expand = columns => $select(columns, 'odata', ';', true)
+const $expand = columns => $select(columns, 'odata', ';')
 
 function $count(count, kind) {
   if (count !== true) return ''
@@ -476,7 +416,9 @@ const _isOdataUrlWithKeys = (url, kind) => kind !== 'rest' && /^[\w\.]+\(.*\)/.t
 const parsers = {
   columns: (cqnPart, url, kind, target, isCount) => !isCount && $select(cqnPart, kind),
   expand: (cqnPart, url, kind, target, isCount) => !isCount && $expand(cqnPart),
+  // eslint-disable-next-line no-unused-vars
   where: (cqnPart, url, kind, target, isCount) => $where(cqnPart, target, kind),
+  // eslint-disable-next-line no-unused-vars
   search: (cqnPart, url, kind, target, isCount) => $search(cqnPart, kind),
   orderBy: (cqnPart, url, kind, target, isCount) => !isCount && $orderBy(cqnPart),
   count: (cqnPart, url, kind, target, isCount) => !isCount && $count(cqnPart, kind),
@@ -503,9 +445,7 @@ function getOptions(cqnPart, url, kind, target, isCount) {
 const _isCount = SELECT => {
   if (SELECT.columns) {
     const columns = getProp(SELECT, 'columns')
-    return columns.some(
-      c => c.func === 'count' && c.as === '$count' && c.args && c.args.length === 1 && c.args[0] === '*'
-    )
+    return columns.some(c => c.func === 'count' && c.as === '$count')
   }
   return false
 }
@@ -535,7 +475,6 @@ const _copyData = data => {
         ? data[property].val
         : data[property]
   }
-
   return copied
 }
 
@@ -581,4 +520,4 @@ function cqn2odata(cqn, kind, model) {
   throw new Error('Unknown CQN object cannot be translated to URL: ' + JSON.stringify(cqn))
 }
 
-module.exports = { cqn2odata, formatVal, getSafeNumber }
+module.exports = cqn2odata

package/libx/odata/index.js

@@ -0,0 +1,80 @@
+const cds = require('../_runtime/cds')
+const { SELECT } = cds.ql
+
+const odata2cqn = require('./odata2cqn')
+const cqn2odata = require('./cqn2odata')
+
+const afterburner = require('./odata2cqn/afterburner')
+const { getSafeNumber: safeNumber } = require('./utils')
+
+const strict = {
+  functions: {
+    contains: 1,
+    startswith: 1,
+    endswith: 1,
+    tolower: 1,
+    toupper: 1,
+    length: 1,
+    indexof: 1,
+    substring: 1,
+    trim: 1,
+    concat: 1,
+    year: 1,
+    month: 1,
+    day: 1,
+    hour: 1,
+    minute: 1,
+    second: 1,
+    time: 1,
+    now: 1
+  }
+}
+
+/*
+ * cds.odata API
+ */
+module.exports = {
+  parse: (url, options = {}) => {
+    // first arg may also be req
+    if (url.url) url = url.url
+    // REVISIT: for okra, remove when no longer needed
+    else if (url.getIncomingRequest) url = url.getIncomingRequest().url
+    url = decodeURIComponent(url)
+
+    options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
+    if (options.service) Object.assign(options, { minimal: true, afterburner: afterburner.for(options.service) })
+    options.safeNumber = safeNumber
+
+    let cqn
+    try {
+      cqn = odata2cqn(url, options)
+    } catch (e) {
+      // REVISIT: additional try in catch isn't nice -> find better way
+      // known gaps -> e.message is a stringified error -> use that
+      // unknown errors -> e is the error to keep
+      let err = e
+      try {
+        err = JSON.parse(e.message)
+      } catch {
+        /* nothing to do */
+      }
+      err.message = 'Parsing URL failed with error: ' + err.message
+      err.statusCode = err.statusCode || 400
+      throw err
+    }
+
+    if (typeof options.afterburner === 'function') cqn = options.afterburner(cqn)
+
+    const query = cqn.SELECT.one ? SELECT.one(cqn.SELECT.from) : SELECT.from(cqn.SELECT.from)
+    Object.assign(query.SELECT, cqn.SELECT)
+
+    // REVISIT: _target vs __target, i.e., pseudo csn vs actual csn
+    // DO NOT USE __target outside of libx/rest!!!
+    query.__target = cqn.__target
+
+    return query
+  },
+  urlify: (cqn, options = {}) => {
+    return cqn2odata(cqn, options.kind, options.model)
+  }
+}