@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/core/Service.js

@@ -1,417 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const validateThat = commons.validator.ParameterValidator.validateThat
-const RepresentationKinds = commons.format.RepresentationKind.Kinds
-const LoggerFacade = commons.logging.LoggerFacade
-const IllegalArgumentError = commons.errors.IllegalArgumentError
-const ComponentManager = require('./ComponentManager')
-const MetadataCache = require('../utils/MetadataCache')
-const PerformanceMonitorFactory = require('../utils/PerformanceMonitor').PerformanceMonitorFactory
-const ServiceResolutions = require('./ServiceResolutions')
-const Context = require('./Context')
-const CommandFactory = require('../invocation/CommandFactory')
-const CommandExecutor = require('../invocation/CommandExecutor')
-const FormatManager = require('../format/FormatManager')
-const InternalServerError = require('../errors/InternalServerError')
-const DebugLogger = require('../logging/DebugLogger')
-
-const IS_DEBUG_REGEXP = new RegExp('[?&]odata-debug=(?:json|html)(?:&|$)')
-const IS_PROFILING_REGEXP = new RegExp('[?&]odata-profile=true(?:&|$)')
-
-/**
- * The definition of the Logger Object that can be registered via .log()
- *
- * @typedef {Object} Logger The logger object/class
- * @property {Function} logger.debug The debug function called with string
- * @property {Function} logger.path The path function called with string
- * @property {Function} logger.info The info function called with string
- * @property {Function} logger.warning The warning function called with string
- * @property {Function} logger.error The error function called with string
- * @property {Function} logger.fatal The fatal function called with string
- */
-
-/**
- * The Service is the main service class where all service components must be registered.
- * This service is the main public API used by the service developer.
- */
-class Service {
-  /**
-   * Constructor.
-   * @param {EdmProvider} edmProvider the entity data model
-   */
-  constructor (edmProvider) {
-    validateThat('edmProvider', edmProvider)
-      .truthy()
-      .typeOf('object')
-
-    this._edmProvider = edmProvider
-
-    this._componentManager = new ComponentManager()
-
-    this._formatManager = new FormatManager()
-    this._bodyParserManager = new FormatManager()
-
-    this._basePath = ''
-    this._loggerFacade = null
-
-    this._metadataCache = null
-    this._metadataETag = null
-
-    this._isTrusted = false
-  }
-
-  /**
-   * Get the EDM.
-   * @returns {Edm} the EDM
-   */
-  getEdm () {
-    return this._edmProvider
-  }
-
-  /**
-   * Get the FormatManager.
-   * @returns {FormatManager} the format manager
-   */
-  getFormatManager () {
-    return this._formatManager
-  }
-
-  /**
-   * (Creates and) returns an instance of MetadataCache to cache MIME-type and locale specific metadata documents.
-   * @returns {MetadataCache} the metadata cache
-   * @private
-   */
-  _getMetadataCache () {
-    if (!this._metadataCache) this._metadataCache = new MetadataCache()
-    return this._metadataCache
-  }
-
-  /**
-   * Returns the base path of the current odata service.
-   * The base path is the part of the URL not belonging to OData
-   * which means that this part of the URL will not be interpreted as an OData resource.
-   *
-   * @returns {string} The base path of the url.
-   */
-  getBasePath () {
-    return this._basePath
-  }
-
-  /**
-   * Sets the base path of the URL.
-   * The OData resource URL starts after this base path and will be interpreted as an OData resource.
-   * @param {string} basePath The base path of the url.
-   * @returns {Service} This instance of odata service.
-   * @throws {InternalServerError} if the provided basePath is not null and does not end with '/'
-   */
-  setBasePath (basePath) {
-    if (basePath !== null && basePath !== undefined && !basePath.endsWith('/')) {
-      throw new InternalServerError("Provided base path must end with '/'")
-    }
-    this._basePath = basePath
-    return this
-  }
-
-  /**
-   * Registers an event listener by its name.
-   * The names are not arbitrary. Currently only the following events are supported:
-   * General listeners: request, error, debug
-   * CRUD listeners: create, read, update, delete
-   * Batch listeners: batch-start, batch-end, atomicity-group-start, atomicity-group-end
-   * @param {string} eventName The name of the listener.
-   * @param {Object} eventListener the listener to register.
-   * @returns {Service} Instance of this service.
-   */
-  on (eventName, eventListener) {
-    const supportedEvents = [
-      'request',
-      'error',
-      'debug',
-      'create',
-      'read',
-      'update',
-      'delete',
-      'atomicity-group-start',
-      'atomicity-group-end',
-      'batch-start',
-      'batch-end'
-    ]
-    if (!supportedEvents.includes(eventName.toLowerCase())) {
-      throw IllegalArgumentError.createForIllegalValue('eventName', ...supportedEvents)
-    }
-    validateThat('eventListener', eventListener).typeOf('function')
-
-    this.getComponentManager().use(eventName, eventListener)
-    this.getLogger().debug('Register listener for ' + eventName)
-    return this
-  }
-
-  /**
-   * Registers a service component by its name. The names are not arbitrary. They must be used
-   * from /lib/core/ComponentManager.Components.
-   *
-   * @param {string} name The name of the component.
-   * @param {*} component the component to register.
-   * @returns {Service} Instance of this service.
-   */
-  use (name, component) {
-    this.getLogger().debug('Register component ' + name)
-    this.getComponentManager().use(name, component)
-    return this
-  }
-
-  /**
-   * Registers a logger. Occurring log events will be sent to this logger instance.
-   * @param {Logger} logger The root logger
-   * @param {Function} formatter Formatter to be used to convert
-   * @returns {Service} Instance of this service.
-   */
-  log (logger, formatter) {
-    this._loggerFacade = new LoggerFacade(logger).setFormatter(formatter)
-    this._componentManager.use(ComponentManager.Components.LOGGER, this._loggerFacade)
-    return this
-  }
-
-  /**
-   * Returns the component manager. The component manager manages all registered components within the library.
-   * @returns {ComponentManager} The component manager
-   */
-  getComponentManager () {
-    return this._componentManager
-  }
-
-  /**
-   * Sets the supported OData version.
-   * @param {string} version - The supported OData version
-   * @returns {Service} this instance of Service
-   */
-  setOdataVersion (version) {
-    this._odataVersion = version
-    this.getLogger().debug('Set OdataVersion to ' + version)
-    return this
-  }
-
-  /**
-   * Returns the supported OData version.
-   * @returns {string} the supported OData version
-   */
-  getOdataVersion () {
-    return this._odataVersion
-  }
-
-  /**
-   * Sets the distinct ETag for the metadata document.
-   * @param {string} etag the ETag for the metadata document
-   * @returns {Service} this instance of Service
-   */
-  setMetadataEtag (etag) {
-    this._metadataETag = etag
-    return this
-  }
-
-  /**
-   * Returns the distinct ETag for the metadata document.
-   * @returns {?string} the ETag for the metadata document
-   */
-  getMetadataEtag () {
-    return this._metadataETag
-  }
-
-  /**
-   * Returns the current logger.
-   * @returns {Logger} The current logger instance
-   */
-  getLogger () {
-    return this._loggerFacade
-  }
-
-  /**
-   * Processes a request. This is the main starting point to use this library.
-   * @param {http.IncomingMessage|PlainHttpRequest} request The request to process.
-   * @param {http.ServerResponse|PlainHttpResponse} response The response to process.
-   * @returns {Promise} a Promise that resolves when the request has been processed successfully
-   */
-  process (request, response) {
-    const logger = this.getLogger()
-
-    // Check if odata-dabug=json|html is part of the request url
-    const isDebugRequested = IS_DEBUG_REGEXP.test(request.url)
-    const isProfiling = isDebugRequested || IS_PROFILING_REGEXP.test(request.url)
-
-    logger.debug('Debug mode requested:', isDebugRequested)
-    logger.debug('Profiling requested:', isProfiling)
-
-    const rootPerformanceMonitor = PerformanceMonitorFactory.getInstance(isProfiling).start()
-
-    logger.debug('Start processing request', request.method, request.url)
-    logger.debug('Using OData base path', this.getBasePath())
-
-    let context
-    let errorFromDebugHandler = null
-    let isDebug = false
-
-    return Promise.resolve()
-      .then(
-        () =>
-          // This Promise handles the setup of the context object.
-          new Promise(resolve => {
-            const serviceResolutionFn = ServiceResolutions.viaBasePath(this._basePath, Boolean(request._batchContext))
-
-            context = new Context(request, response, this, serviceResolutionFn)
-            context.setPerformanceMonitor(rootPerformanceMonitor)
-            context.setLogger(isDebugRequested ? new DebugLogger(logger) : logger)
-            context.getRequest().setService(this)
-
-            if (context.getRequest().getHeaders()) {
-              const headers = Object.assign({}, context.getRequest().getHeaders())
-              // sanatize authorization
-              if (headers.authorization) headers.authorization = headers.authorization.split(' ')[0] + ' ...'
-              logger.debug('Request headers:', headers)
-            }
-
-            resolve()
-          })
-      )
-      .then(
-        () =>
-          // In this Promise, the debug handler gets called and the debug information gets evaluated.
-          new Promise(resolve => {
-            const debugHandler = this.getComponentManager().getComponent('debug')
-            if (debugHandler) {
-              const next = error => {
-                if (error) {
-                  logger.error(error)
-                  errorFromDebugHandler = error
-                } else {
-                  // Check whether debug mode is allowed by the application (default is false) and
-                  // if debug was requested. Only if both are true the request will be executed in debug mode
-                  isDebug =
-                    context
-                      .getRequest()
-                      .getContract()
-                      .isDebug() && isDebugRequested
-                  context
-                    .getRequest()
-                    .getContract()
-                    .enableDebugMode(isDebug)
-                  if (isDebug) {
-                    context.getResponse().setBuffered(true)
-                  }
-                }
-                resolve()
-              }
-
-              // Debug handler gets called here, with the next callback declared above
-              debugHandler(context.getRequest(), context.getResponse(), next)
-            } else {
-              resolve()
-            }
-          })
-      )
-      .then(() => {
-        // This Promise handles the creation and execution of the command chain.
-        const options = {
-          context,
-          componentManager: this._componentManager,
-          formatManager: this._formatManager,
-          bodyParserManager: this._bodyParserManager,
-          isDebug: isDebug,
-          isProfiling
-        }
-        const successCommands = CommandFactory.createForSingleRequest(options)
-        const errorCommands = CommandFactory.createForSingleRequestError(options)
-
-        const executor = new CommandExecutor(context.getLogger(), rootPerformanceMonitor)
-        return new Promise((resolve, reject) => {
-          const endCallback = err => {
-            rootPerformanceMonitor.stop()
-            if (err) {
-              logger.error(err)
-              reject(err)
-            } else {
-              logger.debug('Request processing finished')
-              resolve()
-            }
-          }
-          executor.execute(successCommands, errorCommands, errorFromDebugHandler, endCallback)
-        })
-      })
-  }
-
-  /**
-   * Sets whether we trust in the data provided by the service implementation.
-   * @param {boolean} isTrusted whether we trust in the data provided by the service implementation
-   * @returns {Service} this instance
-   */
-  trust (isTrusted) {
-    this._isTrusted = isTrusted
-    return this
-  }
-
-  /**
-   * Returns whether we trust in the data provided by the service implementation.
-   * @returns {boolean} whether we trust in the data provided by the service implementation
-   */
-  isTrusted () {
-    return this._isTrusted
-  }
-
-  /**
-   * Registers a serializer needed to serialize the result data into the response.
-   * @param {RepresentationKind.Kinds} representationKind Kind of request like 'metadata' or 'resource'.
-   * @param {string} contentType Requested content type like 'application/json'.
-   * @param {Function} serializerFunction The function which will be called on serialization.
-   * @param {Function} [parameterCheckFunction] the function to check the format parameters
-   * @returns {Service} This instance of service.
-   */
-  format (representationKind, contentType, serializerFunction, parameterCheckFunction) {
-    return this._registerDeserializer(
-      this._formatManager,
-      representationKind,
-      contentType,
-      serializerFunction,
-      parameterCheckFunction
-    )
-  }
-
-  /**
-   * Registers a body parsing facade. This facade is responsible for parsing/deserializing the request payload.
-   * @param {RepresentationKind.Kinds} representationKind The corresponding representation kind
-   * @param {ContentTypeInfo.ContentTypes} contentType The corresponding content type
-   * @param {Function} deserializerFunction The deserialization facade to register
-   * @returns {Service} This instance
-   */
-  parse (representationKind, contentType, deserializerFunction) {
-    return this._registerDeserializer(this._bodyParserManager, representationKind, contentType, deserializerFunction)
-  }
-
-  /**
-   * Registers a provided deserializer function at its format manager in dependency of the corresponding
-   * representation kind and content type
-   *
-   * @param {FormatManager} manager The corresponding manager
-   * @param {RepresentationKind.Kinds} representationKind The corresponding representation kind
-   * @param {ContentTypeInfo.ContentTypes} contentType The corresponding content type
-   * @param {Function} parserFunction The parser facade to register
-   * @param {?Function} parameterCheckFunction the function to check the format parameters
-   * @returns {Service} This instance
-   * @private
-   */
-  _registerDeserializer (manager, representationKind, contentType, parserFunction, parameterCheckFunction) {
-    if (representationKind !== RepresentationKinds.NO_CONTENT) {
-      validateThat('contentType', contentType)
-        .notNullNorUndefined()
-        .typeOf('string')
-    }
-    validateThat('serializerFunction', parserFunction)
-      .truthy()
-      .typeOf('function')
-
-    manager.use(representationKind, contentType, parserFunction, parameterCheckFunction)
-
-    return this
-  }
-}
-
-module.exports = Service

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/core/ServiceResolutions.js

@@ -1,24 +0,0 @@
-'use strict'
-
-class ServiceResolutions {
-  /**
-   * The service resolution uses a base path.
-   * @param {string} basePath the base path
-   * @param {boolean} [isBatch] whether the request is part of a batch request
-   * @returns {Function} the service-resolution function
-   */
-  static viaBasePath (basePath, isBatch = false) {
-    return pathname => {
-      if (pathname.startsWith(basePath)) return pathname.substring(basePath.length)
-      // In $batch the following patterns are allowed:
-      // - Absolute URI with schema, host, port, and absolute resource path,
-      //   like http://server:port/path/service/EntitySet(1)
-      // - Absolute resource path, like /path/service/EntitySet(1), and separate Host header
-      // - Resource path relative to the batch request URI, like EntitySet(1)
-      if (isBatch) return pathname
-      throw new Error("Configured base path '" + basePath + "' does not match provided url path '" + pathname + "'")
-    }
-  }
-}
-
-module.exports = ServiceResolutions

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/ApplicationHttpReader.js

@@ -1,157 +0,0 @@
-'use strict'
-
-const HeaderReader = require('./HeaderReader')
-const LineReader = require('./LineReader')
-const Reader = require('./Reader')
-
-/**
- * States
- * @enum {number}
- * @readonly
- */
-const STATES = {
-  READ_REQUEST_LINE: 0,
-  READ_REQUEST_LINE_RETURN: 1,
-  RUN_HEADER_READER: 2,
-  RUN_HEADER_READER_RETURN: 3,
-  RUN_READER: 4,
-  RUN_READER_RETURN: 5,
-  FINISHED: 6
-}
-
-/**
- * Events
- * @enum {string}
- * @readonly
- */
-const EVENTS = {
-  START: 'request.start',
-  REQUEST_LINE: 'request.requestline',
-  HEADERS: 'request.headers',
-  BODY_START: 'request.body.start',
-  BODY_END: 'request.body.end',
-  END: 'request.end'
-}
-
-const BODY_PREFIX = 'body'
-
-/**
- *
- * Reading a application/http request from the cache. The request must be in the format described by mime type application/http
- * and the cache must start with the request line
- *
- * @extends Reader
- */
-class ApplicationHttpReader extends Reader {
-  /**
-   * Factory for automatic creation depending on content-type
-   * @returns {ApplicationHttpReader} a new instance of this class
-   */
-  static createInstance () {
-    return new ApplicationHttpReader()
-  }
-
-  /**
-   * Constructor
-   */
-  constructor () {
-    super()
-
-    this._state = STATES.READ_REQUEST_LINE
-
-    this._headerInfos = null
-
-    this._headerReader = null
-    this._bodyReader = null
-
-    /**
-     * Request line (e.g. POST /service/$batch HTTP/1.1) without leading/trailing CRLFs
-     * @private
-     */
-    this._requestLine = null
-    this._stopPattern = null
-  }
-
-  /**
-   * Set the stop pattern. E.g. when mime type application/http is used inside a multipart request
-   * @param {string} stopPattern the stop pattern
-   */
-  setStopPattern (stopPattern) {
-    this._stopPattern = stopPattern
-  }
-
-  /**
-   * Read data from cache until the boundary is read. If the cache is empty and more data is required,
-   * this is signaled and readCache is called again. The state is preserved.
-   *
-   * @param {ContentDeserializer} reader the reader
-   * @returns {boolean}
-   *      this: this reader needs more data and caller should call this method again with more data in cache
-   *      false: this reader is finished caller should pop this reader from stack
-   *      null:  new sub reader is on stack, call this method again after the sub reader is finished
-   */
-  readCache (reader) {
-    let needMoreData = false
-
-    while (needMoreData === false && this._state !== STATES.FINISHED) {
-      switch (this._state) {
-        case STATES.READ_REQUEST_LINE:
-          this.emit(EVENTS.START)
-          this.lineReader = new LineReader()
-          reader.pushReader(this.lineReader)
-          this._state = STATES.READ_REQUEST_LINE_RETURN
-          needMoreData = null
-          break
-
-        case STATES.READ_REQUEST_LINE_RETURN:
-          this._requestLine = this.lineReader.getLine()
-          this.emit(EVENTS.REQUEST_LINE, this._requestLine)
-          this._state = STATES.RUN_HEADER_READER
-          break
-
-        case STATES.RUN_HEADER_READER:
-          this._headerReader = new HeaderReader().setEmitter(this._emitter)
-          reader.pushReader(this._headerReader)
-          this._state = STATES.RUN_HEADER_READER_RETURN
-          needMoreData = null
-          break
-
-        case STATES.RUN_HEADER_READER_RETURN:
-          this._headerInfos = this._headerReader.getHeaderInfos()
-          this._headerInfosRaw = this._headerReader.getHeaderInfosRaw()
-          this.emit(EVENTS.HEADERS, this._headerInfosRaw, this._headerInfos)
-          this._state = STATES.RUN_READER
-          break
-
-        case STATES.RUN_READER:
-          this._bodyReader = reader.getNextReader(this._headerInfos).setEmitter(this._emitter, BODY_PREFIX)
-          if (this._stopPattern) {
-            this._bodyReader.setStopPattern(this._stopPattern)
-          }
-          reader.pushReader(this._bodyReader)
-
-          this.emit(EVENTS.BODY_START)
-          this._state = STATES.RUN_READER_RETURN
-          needMoreData = null
-          break
-
-        case STATES.RUN_READER_RETURN:
-          this.emit(EVENTS.BODY_END)
-          this.emit(EVENTS.END)
-          this._state = STATES.FINISHED
-          needMoreData = false
-          break
-
-        default:
-          break
-      }
-    }
-
-    return needMoreData
-  }
-}
-
-ApplicationHttpReader.EVENTS = EVENTS
-ApplicationHttpReader.BODY_PREFIX = BODY_PREFIX
-
-module.exports = ApplicationHttpReader