@sap/cds 5.9.7 → 6.0.2

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

@@ -1,70 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

package/libx/gql/schema/mutation.js

@@ -1,76 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

package/libx/rest/middleware/auth.js

@@ -1,20 +0,0 @@
-const { UNAUTHORIZED, FORBIDDEN, getRequiresAsArray } = require('../../_runtime/auth/utils')
-
-module.exports = (req, res, next) => {
-  if (!req._srv._requires) req._srv._requires = getRequiresAsArray(req._srv.definition)
-
-  const { _requires: requires } = req._srv
-
-  if (req.path !== '/' && requires.length > 0 && !requires.some(r => req.user.is(r))) {
-    // > unauthorized or forbidden?
-    if (req.user._is_anonymous) {
-      if (req.user._challenges) res.set('WWW-Authenticate', req.user._challenges.join(';'))
-      // REVISIT: security log in else case?
-      throw UNAUTHORIZED
-    }
-    // REVISIT: security log?
-    throw FORBIDDEN
-  }
-
-  next()
-}

package/libx/rest/middleware/content.js

@@ -1,19 +0,0 @@
-const PPP = { POST: 1, PUT: 1, PATCH: 1 }
-const UPDATE = { PUT: 1, PATCH: 1 }
-
-module.exports = (req, res, next) => {
-  if (PPP[req.method]) {
-    const contentType = req.headers['content-type'] && req.headers['content-type'].split(';')
-    if (
-      contentType &&
-      (!contentType[0].match(/^application\/json$/) || (typeof contentType[1] === 'string' && !contentType[1]))
-    ) {
-      throw { statusCode: 415, code: '415', message: 'INVALID_CONTENT_TYPE_ONLY_JSON' }
-    }
-    if (UPDATE[req.method] && Array.isArray(req.body)) {
-      throw { statusCode: 400, code: '400', message: `INVALID_${req.method}` }
-    }
-  }
-
-  next()
-}

package/srv/flex.cds

@@ -1,21 +0,0 @@
-namespace cds_r; //> cds system tables
-
-type JSON: String;
-
-@protocol: 'rest' 
-service ExtensibilityService @(path:'/-/cds/extensibility') {
-  action addExtension(extensions : array of String); // TODO: change to array of CSN extensions
-  action activate(tenant: String);
-  action activateProject(tenant: String, extension: array of { filename: String; model: JSON }, undeployExtension: Boolean);
-}
-
-entity Extensions {
-  key ID    : UUID;
-  csn       : String;
-  activated : Boolean; // <-- status / enum ?
-}
-
-// @open type Extension {
-//   extend: String;
-//   elements:{ /*  */ }
-// }

package/srv/flex.js

@@ -1 +0,0 @@
-module.exports = require('../libx/_runtime/extensibility/uiflex/service')

package/srv/mps.cds

@@ -1,23 +0,0 @@
-namespace cds_r; //> cds system tables
-
-type TenantID : String;
-@open type CSN {};
-type XML : String;
-type Locale : String;
-type TAR : LargeBinary;
-
-/**
- * Used by CAP runtimes to retrieve tenant-specific variants of
- * deployed models used to serve requests.
- */
-@(requires : [
-   'mtcallback'
-])
-@protocol: 'rest'
-service ModelProviderService @(path:'/-/cds/model-provider') {
-  action isExtended(tenant : TenantID) returns Boolean;
-  action getCsn(tenant : TenantID, toggles : array of String, flavor: String enum { nodejs; java; }) returns CSN;
-  action getOdataCsn(tenant : TenantID, toggles : array of String) returns CSN; // REVISIT: Replace by getCsn(..., flavor=node/java)
-  action getEdmx(tenant : TenantID, toggles : array of String, serviceName : String, locale : Locale, odataFlavor : String) returns XML;
-  action getResources(flat : Boolean) returns TAR;
-}

package/srv/mps.js

@@ -1 +0,0 @@
-module.exports = require('../libx/_runtime/extensibility/mps/service')