@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/FilterParser.js

@@ -1,34 +0,0 @@
-'use strict'
-
-const ExpressionParser = require('./ExpressionParser')
-const EdmPrimitiveTypeKind = require('../edm/EdmPrimitiveTypeKind')
-
-class FilterParser {
-  /**
-   * Create a filter parser.
-   * @param {Edm} edm entity data model
-   */
-  constructor (edm) {
-    this._edm = edm
-  }
-
-  /**
-   * Parse a filter string into an expression tree.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @param {?EdmType} referencedType type the expression references
-   * @param {?(EdmEntitySet[])} crossjoinEntitySets entity sets in case of a $crossjoin request
-   * @param {?Object} aliases alias definitions
-   * @returns {Expression} the root of the expression tree
-   * @throws {UriSyntaxError}
-   * @throws {UriQueryOptionSemanticError}
-   */
-  parse (tokenizer, referencedType, crossjoinEntitySets, aliases) {
-    const expressionParser = new ExpressionParser(this._edm)
-    const filterExpression = expressionParser.parse(tokenizer, referencedType, crossjoinEntitySets, aliases)
-    expressionParser.checkNoCollection(filterExpression)
-    expressionParser.checkType(filterExpression, EdmPrimitiveTypeKind.Boolean)
-    return filterExpression
-  }
-}
-
-module.exports = FilterParser

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/FunctionParameterParser.js

@@ -1,106 +0,0 @@
-'use strict'
-
-const UriSemanticError = require('../errors/UriSemanticError')
-const KeyValueParser = require('./KeyValueParser')
-const TokenKind = require('./UriTokenizer').TokenKind
-
-/**
- * Parsing function parameters of a URI.
- * @extends KeyValueParser
- */
-class FunctionParameterParser extends KeyValueParser {
-  /**
-   * Creates an instance of FunctionParameterParser.
-   * @param {Edm} edm The Entity Data Model
-   * @param {Object} aliases Alias definitions
-   */
-  constructor (edm, aliases) {
-    super(edm, aliases)
-
-    this._function = null
-    this._uriParameters = []
-  }
-
-  /**
-   * Parse the function parameters in the URL.
-   * @param {string} boundFunctionOrFunctionImportName Name of the bound function or of the function import
-   * @param {EdmFunction[]} functions array of functions
-   * @param {UriTokenizer} tokenizer The current tokenizer
-   * @param {Function} getOverloadingFunctionFn Callback function how to get the overloaded function.
-   * The callback will be called with a Map object.
-   * @returns {UriParameter[]} an array with found parameters
-   */
-  parse (boundFunctionOrFunctionImportName, functions, tokenizer, getOverloadingFunctionFn) {
-    this._function = null
-    this._uriParameters = []
-
-    if (!tokenizer.next(TokenKind.OPEN)) return null
-
-    function testFunctionExists (func, visitedParameters) {
-      if (!func) {
-        throw new UriSemanticError(
-          UriSemanticError.Message.FUNCTION_NOT_FOUND,
-          boundFunctionOrFunctionImportName,
-          Array.from(visitedParameters.keys()).join(',')
-        )
-      }
-    }
-
-    if (tokenizer.next(TokenKind.CLOSE)) {
-      this._function = getOverloadingFunctionFn(new Map())
-      testFunctionExists(this._function, [])
-      return this._uriParameters
-    }
-
-    let allAvailableParameterTypes = new Map()
-    for (const func of functions) {
-      for (const [name, parameter] of func.getParameters()) {
-        if (!allAvailableParameterTypes.has(name)) {
-          allAvailableParameterTypes.set(name, new Set())
-        }
-        if (parameter.isNullable()) {
-          allAvailableParameterTypes.get(name).add('nullable')
-        }
-        const type = parameter.getType()
-        allAvailableParameterTypes.get(name).add(type)
-      }
-    }
-
-    const visitedParameters = super.parse(
-      tokenizer,
-      parameterName => allAvailableParameterTypes.get(parameterName),
-      parameterTypeSet => Array.from(parameterTypeSet.values())
-    )
-
-    tokenizer.requireNext(TokenKind.CLOSE)
-
-    this._function = getOverloadingFunctionFn(visitedParameters)
-
-    testFunctionExists(this._function, visitedParameters)
-
-    for (const [key, value] of visitedParameters) {
-      const parameter = this._function.getParameter(key)
-      this._uriParameters.push(value.setEdmRef(parameter))
-    }
-
-    return this._uriParameters
-  }
-
-  /**
-   * Returns the current overloaded function.
-   * @returns {?EdmFunction} the current overloaded function
-   */
-  getFunction () {
-    return this._function
-  }
-
-  /**
-   * Returns the current found function parameters.
-   * @returns {UriParameter[]} the current found function parameters
-   */
-  getParameters () {
-    return this._uriParameters
-  }
-}
-
-module.exports = FunctionParameterParser

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/KeyPredicateParser.js

@@ -1,155 +0,0 @@
-'use strict'
-
-const UriSemanticError = require('../errors/UriSemanticError')
-const KeyValueParser = require('./KeyValueParser')
-const UriTokenizer = require('./UriTokenizer')
-const TokenKind = UriTokenizer.TokenKind
-const UriParameter = require('./UriParameter')
-const UriHelper = require('./UriHelper')
-const EdmTypeKind = require('../edm/EdmType').TypeKind
-const EdmPrimitiveTypeKind = require('../edm/EdmPrimitiveTypeKind')
-
-/**
- * Parser for URI key predicates.
- * @extends KeyValueParser
- */
-class KeyPredicateParser extends KeyValueParser {
-  /**
-   * Parses the key predicates from the tokenizer.
-   * @param {UriResource} currentResource The current resource
-   * @param {EdmEntityType} edmEntityType the EDM type of the current resource
-   * @param {UriTokenizer} tokenizer the current URI tokenizer
-   * @returns {UriParameter[]} the found key predicates
-   */
-  parse (currentResource, edmEntityType, tokenizer) {
-    const requiredKeyProperties = this._buildRequiredKeyProperties(currentResource, edmEntityType)
-    return [].concat(
-      requiredKeyProperties.size > 1
-        ? this._parseCompoundKey(requiredKeyProperties, edmEntityType, tokenizer)
-        : this._parseSimpleKey(requiredKeyProperties, edmEntityType, tokenizer)
-    )
-  }
-
-  /**
-   * Parses the key predicates from URI segments following the key-as-segment convention.
-   * @param {UriResource} currentResource the current resource
-   * @param {string[]} uriPathSegments the URI path segments
-   * @returns {?(UriParameter[])} the found key predicates or null if not all key predicates have been found
-   */
-  parseKeyPathSegments (currentResource, uriPathSegments) {
-    const edmEntityType = currentResource.getEdmType()
-    let keyPredicates = []
-    for (const propertyRef of this._buildRequiredKeyProperties(currentResource, edmEntityType).values()) {
-      const value = uriPathSegments[keyPredicates.length]
-      if (value === undefined) return null
-      let type = propertyRef.getProperty().getType()
-      if (type.getKind() === EdmTypeKind.ENUM) {
-        if (super.parseEnumValue(type, value) === null) return null
-      } else {
-        if (type.getKind() === EdmTypeKind.DEFINITION) type = type.getUnderlyingType()
-        if (type === EdmPrimitiveTypeKind.Duration) {
-          let tokenizer = new UriTokenizer(UriHelper.toUriLiteral(value, type))
-          if (!tokenizer.next(TokenKind.DurationValue)) return null
-          if (!tokenizer.next(TokenKind.EOF)) return null
-        } else if (type !== EdmPrimitiveTypeKind.String) {
-          let tokenizer = new UriTokenizer(value)
-          if (!super.getTokenKindsForType(type).some(kind => tokenizer.next(kind))) return null
-          if (!tokenizer.next(TokenKind.EOF)) return null
-        }
-      }
-      keyPredicates.push(new UriParameter().setText(value, type).setEdmRef(propertyRef))
-    }
-    return keyPredicates
-  }
-
-  /**
-   * Builds the required key properties map.
-   * @param {UriResource} currentResource The current resource
-   * @param {EdmEntityType} edmEntityType the EDM entity type of the current resource
-   * @returns {Map.<string, EdmKeyPropertyRef>} the map of required key properties
-   * @private
-   */
-  _buildRequiredKeyProperties (currentResource, edmEntityType) {
-    let requiredKeyProperties = new Map(edmEntityType.getKeyPropertyRefs())
-
-    const navigationProperty = currentResource.getNavigationProperty()
-    if (navigationProperty) {
-      const partner = navigationProperty.getPartner()
-      if (partner) {
-        // "If a navigation property leading to a related entity type has a
-        // partner navigation property that specifies a referential constraint,
-        // then those key properties of the related entity that take part in
-        // the referential constraint MAY be omitted from URLs."
-        for (const name of partner.getReferentialConstraints().keys()) {
-          requiredKeyProperties.delete(name)
-        }
-      }
-    }
-
-    return requiredKeyProperties
-  }
-
-  _isViewWithParameterWithDefaultValue (name, edmEntityType) {
-    return edmEntityType.getNavigationProperty('Set') && edmEntityType.getStructuralProperty(name) && edmEntityType.getStructuralProperty(name)._csdlObject.defaultValue
-  }
-
-  /**
-   * Parses a compound key.
-   * @param {string[]} requiredKeyProperties The required key property names
-   * @param {EdmEntityType} edmEntityType the current EDM entity type
-   * @param {UriTokenizer} tokenizer the current URI tokenizer
-   * @returns {UriParameter[]} the found key predicates
-   * @private
-   */
-  _parseCompoundKey (requiredKeyProperties, edmEntityType, tokenizer) {
-    const visitedKeyProperties = super.parse(
-      tokenizer,
-      propertyRefName => edmEntityType.getKeyPropertyRef(propertyRefName),
-      propertyRefType => [propertyRefType.getProperty().getType()]
-    )
-    // searching for default values in views with parameters, otherwise missing key should result in error
-    const missingDefaultKeys = Array.from(requiredKeyProperties.keys()).filter(
-      name => !visitedKeyProperties.has(name) && this._isViewWithParameterWithDefaultValue(name, edmEntityType)
-    )
-    if (missingDefaultKeys.length > 0) {
-      missingDefaultKeys.forEach(element => visitedKeyProperties.set(element, new UriParameter().setText(edmEntityType.getStructuralProperty(element)._csdlObject.defaultValue)))
-    }
-    // Testing if at least all required key properties have been visited
-    const missingKeyPredicateNames = Array.from(requiredKeyProperties.keys()).filter(
-      name => !visitedKeyProperties.has(name)
-    )
-    if (missingKeyPredicateNames.length > 0) {
-      throw new UriSemanticError(UriSemanticError.Message.KEY_PREDICATES_MISSING, missingKeyPredicateNames.join(','))
-    }
-
-    let result = []
-    for (let [key, value] of visitedKeyProperties) {
-      result.push(value.setEdmRef(edmEntityType.getKeyPropertyRef(key)))
-    }
-    return result
-  }
-
-  /**
-   * Parses a simple key.
-   * @param {string[]} requiredKeyProperties The required key property names
-   * @param {EdmEntityType} edmEntityType the current EDM entity type
-   * @param {UriTokenizer} tokenizer The current tokenizer
-   * @returns {UriParameter[]} the found key predicates
-   * @private
-   */
-  _parseSimpleKey (requiredKeyProperties, edmEntityType, tokenizer) {
-    const propertyRef = requiredKeyProperties.values().next().value
-    const propertyRefType = propertyRef.getProperty().getType()
-
-    // First try to parse key when key is like ES(value)
-    let parameter = this.parseUriParameter(propertyRefType, tokenizer)
-    if (parameter) {
-      return [parameter.setEdmRef(propertyRef)]
-    }
-
-    // Second try to parse key when key is like ES(ODataIdentifier=value)
-    return this._parseCompoundKey(requiredKeyProperties, edmEntityType, tokenizer)
-  }
-}
-
-module.exports = KeyPredicateParser

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/KeyValueParser.js

@@ -1,213 +0,0 @@
-'use strict'
-
-const UriSyntaxError = require('../errors/UriSyntaxError')
-const UriSemanticError = require('../errors/UriSemanticError')
-const ErrorNames = require('../errors/AbstractError').ErrorNames
-const UriHelper = require('./UriHelper')
-const TokenKind = require('./UriTokenizer').TokenKind
-const UriParameter = require('./UriParameter')
-const EdmTypeKind = require('../edm/EdmType').TypeKind
-const EdmPrimitiveTypeKind = require('../edm/EdmPrimitiveTypeKind')
-const ExpressionKind = require('./Expression').ExpressionKind
-const FullQualifiedName = require('../FullQualifiedName')
-
-const typeKindToToken = new Map([
-  [EdmPrimitiveTypeKind.String, [TokenKind.StringValue]],
-  [EdmPrimitiveTypeKind.Boolean, [TokenKind.BooleanValue]],
-  [EdmPrimitiveTypeKind.SByte, [TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Byte, [TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Int16, [TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Int32, [TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Int64, [TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Guid, [TokenKind.GuidValue]],
-  [EdmPrimitiveTypeKind.Decimal, [TokenKind.DecimalValue, TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Double, [TokenKind.DoubleValue, TokenKind.DecimalValue, TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Single, [TokenKind.DoubleValue, TokenKind.DecimalValue, TokenKind.IntegerValue]],
-  [EdmPrimitiveTypeKind.Date, [TokenKind.DateValue]],
-  [EdmPrimitiveTypeKind.DateTimeOffset, [TokenKind.DateTimeOffsetValue]],
-  [EdmPrimitiveTypeKind.TimeOfDay, [TokenKind.TimeOfDayValue]],
-  [EdmPrimitiveTypeKind.Duration, [TokenKind.DurationValue]],
-  [EdmPrimitiveTypeKind.Binary, [TokenKind.BinaryValue]],
-  [EdmPrimitiveTypeKind.GeographyPoint, [TokenKind.GeographyPoint]],
-  [EdmPrimitiveTypeKind.GeometryPoint, [TokenKind.GeometryPoint]],
-  [EdmPrimitiveTypeKind.GeographyLineString, [TokenKind.GeographyLineString]],
-  [EdmPrimitiveTypeKind.GeometryLineString, [TokenKind.GeometryLineString]],
-  [EdmPrimitiveTypeKind.GeographyPolygon, [TokenKind.GeographyPolygon]],
-  [EdmPrimitiveTypeKind.GeometryPolygon, [TokenKind.GeometryPolygon]],
-  [EdmPrimitiveTypeKind.GeographyMultiPoint, [TokenKind.GeographyMultiPoint]],
-  [EdmPrimitiveTypeKind.GeometryMultiPoint, [TokenKind.GeometryMultiPoint]],
-  [EdmPrimitiveTypeKind.GeographyMultiLineString, [TokenKind.GeographyMultiLineString]],
-  [EdmPrimitiveTypeKind.GeometryMultiLineString, [TokenKind.GeometryMultiLineString]],
-  [EdmPrimitiveTypeKind.GeographyMultiPolygon, [TokenKind.GeographyMultiPolygon]],
-  [EdmPrimitiveTypeKind.GeometryMultiPolygon, [TokenKind.GeometryMultiPolygon]],
-  [EdmPrimitiveTypeKind.GeographyCollection, [TokenKind.GeographyCollection]],
-  [EdmPrimitiveTypeKind.GeometryCollection, [TokenKind.GeometryCollection]]
-])
-
-/**
- * Abstract class for parsing simple key=value pairs in an uri.
- */
-class KeyValueParser {
-  /**
-   * Constructor to set common values.
-   * @param {Edm} edm The Entity Data Model
-   * @param {Object} aliases Alias definitions
-   */
-  constructor (edm, aliases) {
-    this._edm = edm
-    this._aliases = new Object(aliases) // eslint-disable-line no-new-object
-  }
-
-  /**
-   * Parses a URI parameter. This method decides which data type to read next in the URI string.
-   * @param {EdmType} edmType The current emd type to read for
-   * @param {UriTokenizer} tokenizer The current tokenizer
-   * @returns {?UriParameter} an UriParameter (where the value could be null if a literal null was found)
-   *                          or null if no token was found at all
-   */
-  parseUriParameter (edmType, tokenizer) {
-    if (tokenizer.next(TokenKind.ParameterAliasName)) {
-      const alias = tokenizer.getText()
-      let parameter = new UriParameter().setAlias(alias)
-      // ExpressionParser must be loaded at run-time, not statically at the beginning of this file,
-      // to break the dependency cycle.
-      const ExpressionParser = require('./ExpressionParser') // eslint-disable-line global-require
-      let expression = null
-      try {
-        expression = new ExpressionParser(this._edm).parseAlias(alias, edmType, this._aliases)
-      } catch (err) {
-        throw err.name === ErrorNames.URI_QUERY_OPTION_SEMANTIC
-          ? new UriSemanticError(err.message).setRootCause(err)
-          : err
-      }
-      if (expression.getKind() === ExpressionKind.LITERAL) {
-        parameter.setAliasValue(expression.getText())
-      } else {
-        parameter.setExpression(expression)
-      }
-      return parameter
-    }
-
-    let type = edmType
-    let tokenKinds = null
-
-    if (edmType === 'nullable') {
-      tokenKinds = [TokenKind.NULL]
-    } else if (edmType.getKind() === EdmTypeKind.ENUM) {
-      tokenKinds = [TokenKind.EnumValue]
-    } else {
-      if (edmType.getKind() === EdmTypeKind.DEFINITION) type = edmType.getUnderlyingType()
-      tokenKinds = typeKindToToken.get(type)
-    }
-
-    return tokenKinds.find(kind => tokenizer.next(kind))
-      ? new UriParameter().setText(this.fromUriLiteral(tokenizer.getText(), type))
-      : null
-  }
-
-  /**
-   * Build the normalized string literal form of a value according to its EDM type.
-   * @param {string} uriLiteral The current uri literal
-   * @param {EdmType} edmType The current edm type for converting the literal into
-   * @returns {?string} the converted string or null if uriLiteral is null
-   */
-  fromUriLiteral (uriLiteral, edmType) {
-    if (edmType === 'nullable') {
-      // We return null if the value of the parameter is
-      // 'http://service/.../FunctionImport(ParameterString=null)/...
-      return null
-    }
-
-    if (edmType.getKind() === EdmTypeKind.ENUM) {
-      // An enumeration-type literal value must start with the full-qualified type name.
-      const typeName = uriLiteral.substring(0, uriLiteral.indexOf("'"))
-      if (edmType !== this._edm.getEnumType(FullQualifiedName.createFromNameSpaceAndName(typeName))) {
-        throw new UriSemanticError(UriSemanticError.Message.INCOMPATIBLE_TYPE, typeName, edmType.getFullQualifiedName())
-      }
-      // Only pre-defined values (and their combinations, for flags) are allowed.
-      const literalValue = uriLiteral.substring(typeName.length + 1, uriLiteral.length - 1)
-      if (this.parseEnumValue(edmType, literalValue) === null) {
-        throw new UriSemanticError(UriSemanticError.Message.WRONG_VALUE, typeName, literalValue)
-      }
-    }
-
-    return UriHelper.fromUriLiteral(uriLiteral, edmType)
-  }
-
-  /**
-   * Parse a literal value for an EDM enumeration type.
-   * @param {EdmEnumType} edmType the EDM enumeration type
-   * @param {string} literalValue the literal value
-   * @returns {?number} the enumeration value or null if the literal value is not valid
-   */
-  parseEnumValue (edmType, literalValue) {
-    let enumValue = null
-    for (const value of literalValue.split(',')) {
-      let memberValue = null
-      for (const [name, member] of edmType.getMembers()) {
-        if (value === name || value === member.getValue().toString()) {
-          memberValue = member.getValue()
-          break
-        }
-      }
-      if (memberValue === null || (enumValue !== null && !edmType.isFlags())) return null
-      enumValue = enumValue === null ? memberValue : enumValue | memberValue
-    }
-    return enumValue
-  }
-
-  /**
-   * Parse the key=value pairs in a URI.
-   * @param {UriTokenizer} tokenizer The current tokenizer
-   * @param {Function} getPropertyFn The callback function to get the EdmProperty for a uri key.
-   *                                 Function will be called with string and must return an EdmProperty.
-   * @param {Function} getTypesFn The callback function to get the EdmType for a given edm property.
-   *                              Function will be called with EdmProperty and must return the EdmType
-   *                              of that property.
-   * @returns {Map.<string, UriParameter>} Map of key, value pairs
-   */
-  parse (tokenizer, getPropertyFn, getTypesFn) {
-    let result = new Map()
-
-    do {
-      tokenizer.requireNext(TokenKind.ODataIdentifier)
-      const keyName = tokenizer.getText()
-
-      if (result.get(keyName)) {
-        throw new UriSemanticError(UriSemanticError.Message.DUPLICATE_KEY, keyName)
-      }
-
-      const property = getPropertyFn(keyName)
-      if (!property) {
-        // Throw an error if property does not exist for provided uri key name
-        throw new UriSemanticError(UriSemanticError.Message.WRONG_KEY_NAME, keyName)
-      }
-
-      tokenizer.requireNext(TokenKind.EQ)
-
-      const propertyTypes = getTypesFn(property)
-      let parameter = null
-      for (const propertyType of propertyTypes) {
-        parameter = this.parseUriParameter(propertyType, tokenizer)
-        if (parameter) break
-      }
-      if (!parameter) {
-        throw new UriSyntaxError(UriSyntaxError.Message.KEY_VALUE_NOT_FOUND, propertyTypes.join("' or '"), keyName)
-      }
-      result.set(keyName, parameter)
-    } while (tokenizer.next(TokenKind.COMMA))
-
-    return result
-  }
-
-  /**
-   * Get the allowed token kinds for an EDM primitive type.
-   * @param {EdmPrimitiveTypeKind} edmType the EDM primitive type
-   * @returns {UriTokenizer.TokenKind[]} the allowed token kinds
-   */
-  getTokenKindsForType (edmType) {
-    return typeKindToToken.get(edmType)
-  }
-}
-
-module.exports = KeyValueParser

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/LiteralExpression.js

@@ -1,43 +0,0 @@
-'use strict'
-
-const Expression = require('./Expression')
-
-/**
- * @extends Expression
- * @hideconstructor
- */
-class LiteralExpression extends Expression {
-  /**
-   * Create an instance of LiteralExpression.
-   * @param {?string} text the literal value or null if a literal null has been given
-   * @param {?EdmType} type EDM type of this literal or null if there is none
-   */
-  constructor (text, type) {
-    super(Expression.ExpressionKind.LITERAL)
-    this._text = text
-    this._type = type
-  }
-
-  /**
-   * Return the literal value. This is a string or null if a literal null has been given.
-   * @returns {?string} the literal value
-   */
-  getText () {
-    return this._text
-  }
-
-  /**
-   * Return the EDM type of this expression or null if there is none.
-   * Numeric literals without a dot and without an e return the smallest possible Edm Integer type.
-   * Numeric literals without a dot, without an e, and larger than 2^63 - 1 are considered to be Edm.Decimal.
-   * Numeric literals with an e are considered to be Edm.Double.
-   * Numeric literals with a dot and without an e are supposed to be Edm.Decimal.
-   *
-   * @returns {?EdmType} Type of the literal if detected. The type of the literal is guessed by the parser.
-   */
-  getType () {
-    return this._type
-  }
-}
-
-module.exports = LiteralExpression

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/MemberExpression.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const Expression = require('./Expression')
-
-/**
- * @extends Expression
- * @hideconstructor
- */
-class MemberExpression extends Expression {
-  /**
-   * Create an instance of MemberExpression.
-   * @param {UriResource[]} pathSegments path segments
-   */
-  constructor (pathSegments) {
-    super(Expression.ExpressionKind.MEMBER)
-    this._pathSegments = pathSegments
-  }
-
-  /**
-   * Return the path segments.
-   * @returns {UriResource[]} path segments
-   */
-  getPathSegments () {
-    return this._pathSegments
-  }
-
-  /**
-   * Return the EDM type of this expression or null if there is none.
-   * @returns {?EdmType} the EDM type of this expression or null if there is none
-   */
-  getType () {
-    return this._pathSegments[this._pathSegments.length - 1].getEdmType()
-  }
-
-  /**
-   * Return true if this expression is a collection.
-   * @returns {boolean} true if this expression is a collection, else false
-   */
-  isCollection () {
-    return this._pathSegments[this._pathSegments.length - 1].isCollection()
-  }
-}
-
-module.exports = MemberExpression