@sap/cds 8.9.4 → 9.0.2

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

@@ -1,127 +0,0 @@
-'use strict'
-
-const TokenKind = require('./UriTokenizer').TokenKind
-const BinaryExpression = require('./BinaryExpression')
-const BinaryOperatorKind = BinaryExpression.OperatorKind
-const UnaryExpression = require('./UnaryExpression')
-const UnaryOperatorKind = UnaryExpression.OperatorKind
-const LiteralExpression = require('./LiteralExpression')
-const EdmPrimitiveTypeKind = require('../edm/EdmPrimitiveTypeKind')
-const UriSyntaxError = require('../errors/UriSyntaxError')
-
-const DOUBLEQUOTE_REGEXP = new RegExp('\\\\"', 'g') // matches backslash followed by doublequote
-const BACKSLASH_REGEXP = new RegExp('\\\\\\\\', 'g') // matches two consecutive backslashes
-
-/**
- * Parses search expressions according to the following (rewritten) grammar:
- * <pre>
- * SearchExpression  ::= OrExpression
- * OrExpression      ::= AndExpression ('OR' AndExpression)*
- * AndExpression     ::= Term ('AND'? Term)*
- * Term              ::= ('NOT'? (Word | Phrase)) | ('(' SearchExpression ')')
- * </pre>
- */
-class SearchParser {
-  /**
-   * Parse search expression.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {Expression} the root of the search-expression tree
-   */
-  parse (tokenizer) {
-    return this._parseOrExpression(tokenizer)
-  }
-
-  /**
-   * Parse search expression with zero or more 'OR' operators.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {Expression} expression
-   * @private
-   */
-  _parseOrExpression (tokenizer) {
-    let left = this._parseAndExpression(tokenizer)
-    while (tokenizer.next(TokenKind.OrOperatorSearch)) {
-      let right = this._parseAndExpression(tokenizer)
-      left = new BinaryExpression(left, BinaryOperatorKind.OR, right, EdmPrimitiveTypeKind.Boolean)
-    }
-    return left
-  }
-
-  /**
-   * Parse search expression with zero or more 'AND' operators.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {Expression} expression
-   * @private
-   */
-  _parseAndExpression (tokenizer) {
-    let left = this._parseTerm(tokenizer)
-    while (tokenizer.next(TokenKind.AndOperatorSearch)) {
-      // Could be whitespace or whitespace-surrounded 'AND'.
-      let right = this._parseTerm(tokenizer)
-      left = new BinaryExpression(left, BinaryOperatorKind.AND, right, EdmPrimitiveTypeKind.Boolean)
-    }
-    return left
-  }
-
-  /**
-   * Parse search term.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {Expression} expression
-   * @private
-   */
-  _parseTerm (tokenizer) {
-    if (tokenizer.next(TokenKind.OPEN)) {
-      let expression = this._parseOrExpression(tokenizer)
-      tokenizer.requireNext(TokenKind.CLOSE)
-      return expression
-    } else if (tokenizer.next(TokenKind.NotOperatorSearch)) {
-      return this._parseNot(tokenizer)
-    } else if (tokenizer.next(TokenKind.Word)) {
-      return new LiteralExpression(tokenizer.getText(), undefined)
-    } else if (tokenizer.next(TokenKind.Phrase)) {
-      return this._parsePhrase(tokenizer)
-    }
-    throw new UriSyntaxError(
-      UriSyntaxError.Message.PHRASE_OR_WORD_EXPECTED,
-      tokenizer.getParseString(),
-      tokenizer.getPosition()
-    )
-  }
-
-  /**
-   * Parse search expression after the 'NOT' operator.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {UnaryExpression} unary expression with operator 'NOT'
-   * @private
-   */
-  _parseNot (tokenizer) {
-    if (tokenizer.next(TokenKind.Word)) {
-      return new UnaryExpression(UnaryOperatorKind.NOT, new LiteralExpression(tokenizer.getText(), undefined))
-    } else if (tokenizer.next(TokenKind.Phrase)) {
-      return new UnaryExpression(UnaryOperatorKind.NOT, this._parsePhrase(tokenizer))
-    }
-    throw new UriSyntaxError(
-      UriSyntaxError.Message.SEARCH_NOT_MUST_BE_FOLLOWED_BY_A_TERM,
-      tokenizer.getParseString(),
-      tokenizer.getPosition()
-    )
-  }
-
-  /**
-   * Parse search phrase.
-   * @param {UriTokenizer} tokenizer tokenizer
-   * @returns {LiteralExpression} literal expression
-   * @private
-   */
-  _parsePhrase (tokenizer) {
-    const literal = tokenizer.getText()
-    return new LiteralExpression(
-      literal
-        .substring(1, literal.length - 1)
-        .replace(DOUBLEQUOTE_REGEXP, '"') // Only with regular expressions all occurrences are replaced.
-        .replace(BACKSLASH_REGEXP, '\\'),
-      undefined
-    )
-  }
-}
-
-module.exports = SearchParser

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

@@ -1,80 +0,0 @@
-'use strict'
-
-/**
- * @hideconstructor
- */
-class SelectItem {
-  /** Create a select item. */
-  constructor () {
-    this._path = []
-    this._isAll = false
-    this._allOperationsInSchemaNamespace = null
-  }
-
-  /**
-   * Return the path segments.
-   * @returns {UriResource[]} the path segments
-   */
-  getPathSegments () {
-    return this._path
-  }
-
-  /**
-   * Set the path segments.
-   * @param {UriResource[]} path the path segments
-   * @returns {SelectItem} this select item
-   * @package
-   */
-  setPathSegments (path) {
-    this._path = path
-    return this
-  }
-
-  /**
-   * Return whether '*' has been specified for the (potentially empty) path.
-   * @returns {boolean} whether '*' has been specified
-   */
-  isAll () {
-    return this._isAll
-  }
-
-  /**
-   * Set the information whether '*' has been specified.
-   * @param {boolean} isAll whether '*' has been specified
-   * @returns {SelectItem} this select item
-   * @package
-   */
-  setAll (isAll) {
-    this._isAll = isAll
-    return this
-  }
-
-  /**
-   * Return whether all operations in a schema have been selected.
-   * @returns {boolean} whether all operations in a schema have been selected
-   */
-  isAllOperationsInSchema () {
-    return Boolean(this._allOperationsInSchemaNamespace)
-  }
-
-  /**
-   * Return the namespace for which all operations have been selected.
-   * @returns {?string} the namespace
-   */
-  getAllOperationsInSchemaNamespace () {
-    return this._allOperationsInSchemaNamespace
-  }
-
-  /**
-   * Set the schema namespace for which all operations have been selected.
-   * @param {string} namespace the namespace
-   * @returns {SelectItem} this select item
-   * @package
-   */
-  setAllOperationsInSchema (namespace) {
-    this._allOperationsInSchemaNamespace = namespace
-    return this
-  }
-}
-
-module.exports = SelectItem

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

@@ -1,294 +0,0 @@
-'use strict'
-
-const TokenKind = require('./UriTokenizer').TokenKind
-const EdmTypeKind = require('../edm/EdmType').TypeKind
-const FullQualifiedName = require('../FullQualifiedName')
-const UriResource = require('./UriResource')
-const ResourceKind = UriResource.ResourceKind
-const SelectItem = require('./SelectItem')
-const UriQueryOptionSemanticError = require('../errors/UriQueryOptionSemanticError')
-const UriSemanticError = require('../errors/UriSemanticError')
-const UriSyntaxError = require('../errors/UriSyntaxError')
-const FeatureSupport = require('../FeatureSupport')
-
-class SelectParser {
-  /**
-   * Create a select parser.
-   * @param {Edm} edm entity data model
-   */
-  constructor (edm) {
-    this._edm = edm
-  }
-
-  /**
-   * Parse a select string into an array of select items.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @param {?EdmType} referencedType type the expression references
-   * @param {boolean} referencedIsCollection whether a collection is referenced
-   * @returns {SelectItem[]} the parsed items
-   * @throws {UriSyntaxError}
-   * @throws {UriQueryOptionSemanticError}
-   */
-  parse (tokenizer, referencedType, referencedIsCollection) {
-    let selectItems = []
-    do {
-      const parsedItem = this._parseItem(tokenizer, referencedType, referencedIsCollection)
-      const pathSegments = parsedItem.getPathSegments()
-      const allOperationsInSchemaNamespace = parsedItem.getAllOperationsInSchemaNamespace()
-      if (
-        (pathSegments && pathSegments.length) ||
-        (allOperationsInSchemaNamespace && allOperationsInSchemaNamespace.length) ||
-        parsedItem.isAll()
-      )
-        selectItems.push(parsedItem)
-    } while (tokenizer.next(TokenKind.COMMA))
-    return selectItems
-  }
-
-  /**
-   * Parse a select string into a select item.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @param {?EdmType} referencedType type the expression references
-   * @param {boolean} referencedIsCollection whether a collection is referenced
-   * @returns {SelectItem} the parsed item
-   * @throws {UriSyntaxError}
-   * @throws {UriQueryOptionSemanticError}
-   * @private
-   */
-  _parseItem (tokenizer, referencedType, referencedIsCollection) {
-    let item = new SelectItem()
-    let pathSegments = []
-    if (tokenizer.next(TokenKind.STAR)) {
-      item.setAll(true)
-    } else if (tokenizer.next(TokenKind.QualifiedName)) {
-      // The namespace or its alias could consist of dot-separated OData identifiers.
-      const allOperationsInSchema = this._parseAllOperationsInSchema(tokenizer)
-      if (allOperationsInSchema) {
-        item.setAllOperationsInSchema(allOperationsInSchema)
-      } else {
-        if (!referencedType) {
-          throw new UriQueryOptionSemanticError(UriQueryOptionSemanticError.Message.REFERENCED_NOT_TYPED)
-        }
-
-        const qualifiedName = FullQualifiedName.createFromNameSpaceAndName(tokenizer.getText())
-        const type = this._edm.getEntityType(qualifiedName) || this._edm.getComplexType(qualifiedName)
-        if (type) {
-          FeatureSupport.failUnsupported(FeatureSupport.features.TypeCast, qualifiedName, tokenizer.getPosition())
-
-          if (type.compatibleTo(referencedType)) {
-            pathSegments.push(new UriResource().setKind(ResourceKind.TYPE_CAST).setTypeCast(type))
-            if (tokenizer.next(TokenKind.SLASH)) {
-              tokenizer.requireNext(TokenKind.ODataIdentifier)
-              this._addSelectPath(tokenizer, type, pathSegments)
-            }
-          } else {
-            throw new UriQueryOptionSemanticError(
-              UriSemanticError.Message.INCOMPATIBLE_TYPE,
-              qualifiedName.toString(),
-              referencedType.getFullQualifiedName().toString()
-            )
-          }
-        } else {
-          pathSegments.push(this._parseBoundOperation(tokenizer, qualifiedName, referencedType, referencedIsCollection))
-        }
-      }
-    } else {
-      tokenizer.requireNext(TokenKind.ODataIdentifier)
-      // The namespace or its alias could be a single OData identifier.
-      let allOperationsInSchema = this._parseAllOperationsInSchema(tokenizer)
-      if (allOperationsInSchema) {
-        item.setAllOperationsInSchema(allOperationsInSchema)
-      } else if (referencedType) {
-        this._addSelectPath(tokenizer, referencedType, pathSegments)
-      } else {
-        throw new UriQueryOptionSemanticError(UriQueryOptionSemanticError.Message.REFERENCED_NOT_TYPED)
-      }
-    }
-
-    item.setPathSegments(pathSegments)
-    return item
-  }
-
-  /**
-   * Parse a namespace plus dot plus star indicating all operations in the schema are selected.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @returns {?string} the parsed namespace
-   * @throws {UriSyntaxError}
-   * @throws {UriQueryOptionSemanticError}
-   * @private
-   */
-  _parseAllOperationsInSchema (tokenizer) {
-    const namespace = tokenizer.getText()
-    if (tokenizer.next(TokenKind.DOT)) {
-      tokenizer.requireNext(TokenKind.STAR)
-      // Validate the namespace.  Currently a namespace from a non-default schema is not supported.
-      // There is no direct access to the namespace without loading the whole schema;
-      // however, the default entity container should always be there, so its access methods can be used.
-      if (!this._edm.getEntityContainer(new FullQualifiedName(namespace, this._edm.getEntityContainer().getName()))) {
-        throw new UriQueryOptionSemanticError(UriQueryOptionSemanticError.Message.WRONG_NAMESPACE, namespace)
-      }
-      return namespace
-    }
-    return null
-  }
-
-  /**
-   * Parse a bound operation.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @param {FullQualifiedName} qualifiedName the qualified name of the operation
-   * @param {?EdmType} referencedType type the expression references
-   * @param {boolean} referencedIsCollection whether a collection is referenced
-   * @returns {UriResource} a resource element describing the parsed operation
-   * @throws {UriQueryOptionSemanticError}
-   * @private
-   */
-  _parseBoundOperation (tokenizer, qualifiedName, referencedType, referencedIsCollection) {
-    const boundAction = this._edm.getBoundAction(
-      qualifiedName,
-      referencedType.getFullQualifiedName(),
-      referencedIsCollection
-    )
-    if (boundAction) {
-      return new UriResource().setKind(ResourceKind.BOUND_ACTION).setAction(boundAction)
-    }
-
-    const parameterNames = this._parseFunctionParameterNames(tokenizer)
-    const boundFunction = this._edm.getBoundFunction(
-      qualifiedName,
-      referencedType.getFullQualifiedName(),
-      referencedIsCollection,
-      parameterNames
-    )
-
-    if (!boundFunction) {
-      throw new UriQueryOptionSemanticError(
-        UriSemanticError.Message.FUNCTION_NOT_FOUND,
-        qualifiedName,
-        parameterNames.join(', ')
-      )
-    }
-
-    return new UriResource()
-      .setKind(ResourceKind.BOUND_FUNCTION)
-      .setFunction(boundFunction)
-      .setFunctionParameters(null)
-  }
-
-  /**
-   * Parse a comma-separated list of function-parameter names enclosed in parentheses.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @returns {string[]} the parsed names
-   * @throws {UriSyntaxError}
-   * @private
-   */
-  _parseFunctionParameterNames (tokenizer) {
-    let names = []
-    if (tokenizer.next(TokenKind.OPEN)) {
-      do {
-        tokenizer.requireNext(TokenKind.ODataIdentifier)
-        names.push(tokenizer.getText())
-      } while (tokenizer.next(TokenKind.COMMA))
-      tokenizer.requireNext(TokenKind.CLOSE)
-    }
-    return names
-  }
-
-  /**
-   * Add more to the select path.
-   * @param {UriTokenizer} tokenizer tokenizer containing the string to be parsed
-   * @param {?EdmType} referencedType type the expression references
-   * @param {UriResource[]} path the path segments parsed so far where more will be added to
-   * @throws {UriSyntaxError}
-   * @throws {UriQueryOptionSemanticError}
-   * @private
-   */
-  _addSelectPath (tokenizer, referencedType, path) {
-    const name = tokenizer.getText()
-    const property = referencedType.getStructuralProperty(name)
-
-    const ignoredProperty = referencedType.getIgnoredProperties && referencedType.getIgnoredProperties().get(name)
-
-    if (property && !ignoredProperty) {
-      let kind = null
-      switch (property.getType().getKind()) {
-        case EdmTypeKind.PRIMITIVE:
-        case EdmTypeKind.ENUM:
-        case EdmTypeKind.DEFINITION:
-          kind = property.isCollection() ? ResourceKind.PRIMITIVE_COLLECTION_PROPERTY : ResourceKind.PRIMITIVE_PROPERTY
-          break
-        case EdmTypeKind.COMPLEX:
-          kind = property.isCollection() ? ResourceKind.COMPLEX_COLLECTION_PROPERTY : ResourceKind.COMPLEX_PROPERTY
-          break
-        default:
-      }
-      path.push(
-        new UriResource()
-          .setProperty(property)
-          .setKind(kind)
-          .setIsCollection(property.isCollection())
-      )
-
-      if (property.getType().getKind() === EdmTypeKind.COMPLEX && tokenizer.next(TokenKind.SLASH)) {
-        if (tokenizer.next(TokenKind.QualifiedName)) {
-          const qualifiedName = FullQualifiedName.createFromNameSpaceAndName(tokenizer.getText())
-          const type = this._edm.getComplexType(qualifiedName)
-          if (!type) {
-            throw new UriQueryOptionSemanticError(
-              UriQueryOptionSemanticError.Message.COMPLEX_TYPE_NOT_FOUND,
-              qualifiedName.toString()
-            )
-          }
-
-          FeatureSupport.failUnsupported(FeatureSupport.features.TypeCast, qualifiedName, tokenizer.getPosition())
-
-          if (type.compatibleTo(property.getType())) {
-            path.push(new UriResource().setKind(ResourceKind.TYPE_CAST).setTypeCast(type))
-            if (tokenizer.next(TokenKind.SLASH)) {
-              tokenizer.requireNext(TokenKind.ODataIdentifier)
-              this._addSelectPath(tokenizer, type, path)
-            }
-          } else {
-            throw new UriQueryOptionSemanticError(
-              UriSemanticError.Message.INCOMPATIBLE_TYPE,
-              qualifiedName.toString(),
-              property
-                .getType()
-                .getFullQualifiedName()
-                .toString()
-            )
-          }
-        } else if (tokenizer.next(TokenKind.ODataIdentifier)) {
-          this._addSelectPath(tokenizer, property.getType(), path)
-        } else {
-          throw new UriSyntaxError(
-            UriSyntaxError.Message.TOKEN_KINDS_EXPECTED,
-            [TokenKind.QualifiedName, TokenKind.ODataIdentifier].join(', '),
-            tokenizer.getParseString(),
-            tokenizer.getPosition()
-          )
-        }
-      }
-    } else {
-      const navigationProperty = referencedType.getNavigationProperty(name)
-
-      if (!ignoredProperty) {
-        if (!navigationProperty) {
-          throw new UriQueryOptionSemanticError(
-            UriSemanticError.Message.PROPERTY_NOT_FOUND,
-            name,
-            referencedType.getName()
-          )
-        }
-
-        path.push(
-          new UriResource()
-            .setNavigationProperty(navigationProperty)
-            .setKind(ResourceKind.NAVIGATION_TO_ONE)
-            .setIsCollection(navigationProperty.isCollection())
-        )
-      }
-    }
-  }
-}
-
-module.exports = SelectParser

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

@@ -1,28 +0,0 @@
-'use strict'
-
-const Expression = require('./Expression')
-
-/**
- * @extends Expression
- * @hideconstructor
- */
-class TypeLiteralExpression extends Expression {
-  /**
-   * Create an instance of TypeLiteralExpression.
-   * @param {?EdmType} type EDM type corresponding to this literal type (null is a valid type)
-   */
-  constructor (type) {
-    super(Expression.ExpressionKind.TYPE_LITERAL)
-    this._type = type
-  }
-
-  /**
-   * Return the EDM type of this expression, i.e., the defined type (null is a valid type).
-   * @returns {?EdmType} the EDM type of this expression (can be null)
-   */
-  getType () {
-    return this._type
-  }
-}
-
-module.exports = TypeLiteralExpression

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

@@ -1,64 +0,0 @@
-'use strict'
-
-const Expression = require('./Expression')
-
-/**
- * @extends Expression
- * @hideconstructor
- */
-class UnaryExpression extends Expression {
-  /**
-   * Create an instance of UnaryExpression.
-   * @param {UnaryExpression.OperatorKind} operator operator
-   * @param {Expression} operand operand
-   */
-  constructor (operator, operand) {
-    super(Expression.ExpressionKind.UNARY)
-    /**
-     * @type {UnaryExpression.OperatorKind}
-     * @private
-     */
-    this._operator = operator
-    /**
-     * @type {Expression}
-     * @private
-     */
-    this._operand = operand
-  }
-
-  /**
-   * Return the operator.
-   * @returns {UnaryExpression.OperatorKind} the operator
-   */
-  getOperator () {
-    return this._operator
-  }
-
-  /**
-   * Return the operand.
-   * @returns {Expression} the operand
-   */
-  getOperand () {
-    return this._operand
-  }
-
-  /**
-   * 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._operand.getType()
-  }
-}
-
-/**
- * Defined operators.
- * @enum {string}
- * @readonly
- */
-UnaryExpression.OperatorKind = {
-  MINUS: '-',
-  NOT: 'not'
-}
-
-module.exports = UnaryExpression

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

@@ -1,65 +0,0 @@
-'use strict'
-
-const EdmTypeKind = require('../edm/EdmType').TypeKind
-const EdmPrimitiveTypeKind = require('../edm/EdmPrimitiveTypeKind')
-const { toBase64url } = require('../../../../../../common/utils/binary')
-
-const REGEXP_SINGLE_QUOTE = new RegExp("'", 'g')
-const REGEXP_TWO_SINGLE_QUOTES = new RegExp("''", 'g')
-
-/**
- * UriHelper has utility methods for reading and constructing URIs.
- */
-class UriHelper {
-  /**
-   * 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
-   */
-  static fromUriLiteral (uriLiteral, edmType) {
-    if (edmType === EdmPrimitiveTypeKind.String) {
-      return uriLiteral.substring(1, uriLiteral.length - 1).replace(REGEXP_TWO_SINGLE_QUOTES, "'")
-    }
-
-    if (edmType === EdmPrimitiveTypeKind.Binary) {
-      // convert the URL-safe base64 encoding to the standard variant (with padding, if necessary)
-      const val = uriLiteral.substring(uriLiteral.indexOf("'") + 1, uriLiteral.length - 1)
-      return Buffer.from(val, 'base64').toString('base64')
-    }
-
-    if (edmType === EdmPrimitiveTypeKind.Duration || edmType.getKind() === EdmTypeKind.ENUM || edmType.getName().startsWith('Geo')) {
-      return uriLiteral.substring(uriLiteral.indexOf("'") + 1, uriLiteral.length - 1)
-    }
-
-    if (edmType.getKind() === EdmTypeKind.DEFINITION) {
-      return UriHelper.fromUriLiteral(uriLiteral, edmType.getUnderlyingType())
-    }
-
-    return uriLiteral
-  }
-
-  /**
-   * Build the URI string literal form of a value given as string according to its EDM type.
-   *
-   * @param {string} value the value
-   * @param {EdmType} edmType the EDM type of the value
-   * @returns {string} the converted string
-   */
-  static toUriLiteral (value, edmType) {
-    if (value === null) return 'null'
-    if (edmType === EdmPrimitiveTypeKind.String) return "'" + value.replace(REGEXP_SINGLE_QUOTE, "''") + "'"
-    if (edmType === EdmPrimitiveTypeKind.Duration) return "duration'" + value + "'"
-    if (edmType === EdmPrimitiveTypeKind.Binary) return "binary'" + toBase64url(value) + "'"
-    if (edmType.getKind() === EdmTypeKind.DEFINITION) {
-      return UriHelper.toUriLiteral(value, edmType.getUnderlyingType())
-    }
-    if (edmType.getKind() === EdmTypeKind.ENUM) return edmType.getFullQualifiedName() + "'" + value + "'"
-    if (edmType.getName().startsWith('Geography')) return "geography'" + value + "'"
-    if (edmType.getName().startsWith('Geometry')) return "geometry'" + value + "'"
-    return value
-  }
-}
-
-module.exports = UriHelper