@sap/cds 8.6.1 → 8.7.0

package/libx/_runtime/common/code-ext/WorkerPool.js

@@ -1,90 +0,0 @@
-const cds = require('../../cds')
-const os = require('os')
-const { Worker } = require('worker_threads')
-
-class ExtensionWorker extends Worker {
-  constructor(id, workerPath, options) {
-    super(workerPath, options)
-    this.id = id
-    this.tasksAssigned = 0
-  }
-}
-
-class WorkerPool {
-  static instances = []
-  constructor(workerPath, options) {
-    this.workerPath = workerPath
-    this.options = options
-    this.size = options.size ?? Math.max(os.cpus().length, 1)
-    this.idleWorkers = new Set()
-    this.workers = []
-    WorkerPool.instances.push(this)
-  }
-
-  #createWorker() {
-    const id = cds.utils.uuid()
-    const worker = new ExtensionWorker(id, this.workerPath, {
-      workerData: { id },
-      resourceLimits: this.options.resourceLimits
-    })
-    worker.on('exit', this.#onWorkerExit.bind(this, worker))
-    return worker
-  }
-
-  #onWorkerExit(worker) {
-    this.idleWorkers.delete(worker)
-    this.workers.splice(this.workers.indexOf(worker), 1)
-    worker.tasksAssigned = 0
-  }
-
-  adquire() {
-    if (this.idleWorkers.size === 0 && this.workers.length < this.size) {
-      const worker = this.#createWorker()
-      this.idleWorkers.add(worker)
-      this.workers.push(worker)
-    }
-
-    const worker = this.idleWorkers.values().next().value
-
-    if (worker) {
-      this.idleWorkers.delete(worker)
-      worker.tasksAssigned++
-      return worker
-    }
-
-    const randomWorkerIndex = Math.floor(Math.random() * this.workers.length)
-    const busyWorker = this.workers[randomWorkerIndex]
-    busyWorker.tasksAssigned++
-    return busyWorker
-  }
-
-  release(worker) {
-    if (worker.tasksAssigned === 0) return
-
-    worker.tasksAssigned--
-    if (worker.tasksAssigned === 0) {
-      this.idleWorkers.add(worker)
-    }
-  }
-
-  async destroy() {
-    if (this.workers.length === 0) return
-
-    const workers = Array.from(this.workers)
-    const iterable = workers.map(worker => {
-      worker.removeAllListeners()
-      return worker.terminate()
-    })
-
-    await Promise.all(iterable)
-    this.idleWorkers = new Set()
-    this.workers = []
-    WorkerPool.instances = []
-  }
-
-  static async destroyAll() {
-    for (const workerPool of WorkerPool.instances) await workerPool.destroy()
-  }
-}
-
-module.exports = WorkerPool

package/libx/_runtime/common/code-ext/WorkerReq.js

@@ -1,77 +0,0 @@
-const { parentPort } = require('worker_threads')
-const { Responses, Errors } = require('../../../../lib/req/response')
-
-class WorkerReq {
-  constructor(contextId, reqData) {
-    this.contextId = contextId
-    Object.assign(this, reqData)
-    this.postMessages = []
-    this.messages = this.messages ?? []
-    this.errors = this.errors ?? new Errors()
-  }
-
-  #push(args) {
-    this.postMessages.push({
-      kind: 'run',
-      target: 'req',
-      ...args
-    })
-  }
-
-  notify(...args) {
-    this.#push({
-      prop: 'notify',
-      args
-    })
-
-    const notify = Responses.get(1, ...args)
-    this.messages.push(notify)
-    return notify
-  }
-
-  info(...args) {
-    this.#push({
-      prop: 'info',
-      args
-    })
-
-    const info = Responses.get(2, ...args)
-    this.messages.push(info)
-    return info
-  }
-
-  warn(...args) {
-    this.#push({
-      prop: 'warn',
-      args
-    })
-
-    const warn = Responses.get(3, ...args)
-    this.messages.push(warn)
-    return warn
-  }
-
-  error(...args) {
-    this.#push({
-      prop: 'error',
-      args
-    })
-
-    let error = Responses.get(4, ...args)
-    if (!error.stack) Error.captureStackTrace((error = Object.assign(new Error(), error)), this.error)
-    this.errors.push(error)
-    return error
-  }
-
-  reject(...args) {
-    parentPort.postMessage({
-      contextId: this.contextId,
-      kind: 'run',
-      target: 'req',
-      prop: 'reject',
-      args
-    })
-  }
-}
-
-module.exports = WorkerReq

package/libx/_runtime/common/code-ext/config.js

@@ -1,13 +0,0 @@
-const os = require('os')
-const totalMemory = os.totalmem() // total amount of system memory in bytes
-const maxOldGenerationSizeMb = Math.floor(totalMemory / 1024 ** 2 / 8) // max size of the main heap in MB
-const maxYoungGenerationSizeMb = Math.floor(totalMemory / 1024 ** 2 / 8) // max size of a heap space for recently created objects
-
-module.exports = {
-  timeout: 10000,
-  resourceLimits: {
-    maxOldGenerationSizeMb,
-    maxYoungGenerationSizeMb,
-    stackSizeMb: 4 // default
-  }
-}

package/libx/_runtime/common/code-ext/execute.js

@@ -1,123 +0,0 @@
-const cds = require('../../cds')
-const path = require('path')
-const { AsyncResource } = require('async_hooks')
-const { timeout, resourceLimits } = require('./config')
-const WorkerPool = require('./WorkerPool')
-const workerPath = path.resolve(__dirname, 'worker.js')
-const workerPool = new WorkerPool(workerPath, { resourceLimits })
-const { Errors } = require('../../../../lib/req/response')
-const LOG = cds.log()
-const _getReqData = req => {
-  return {
-    data: req.data,
-    params: req.params,
-    results: req.results,
-    messages: req.messages,
-    errors: req.errors ?? new Errors()
-  }
-}
-
-module.exports = async function executeCode(code, req) {
-  const reqData = _getReqData(req)
-  const srv = this
-  const _getTarget = target => {
-    switch (target) {
-      case 'srv':
-        return srv
-
-      case 'req':
-        return req
-
-      // no default
-    }
-  }
-
-  const worker = workerPool.adquire()
-  const workerId = worker.id
-  const contextId = cds.utils.uuid()
-  const executePromise = new Promise(function executeCodePromiseExecutor(resolve, reject) {
-    queueMicrotask(AsyncResource.bind(onStarted)) // eslint-disable-line no-undef
-    const onMessageReceivedProxy = AsyncResource.bind(onMessageReceived)
-    const onErrorProxy = AsyncResource.bind(onError)
-    const onExitProxy = AsyncResource.bind(onExit)
-    worker.on('message', onMessageReceivedProxy)
-    worker.on('error', onErrorProxy)
-    worker.on('exit', onExitProxy)
-
-    let onStartTimeoutID
-    function onStarted() {
-      onStartTimeoutID = setTimeout(() => {
-        worker.terminate()
-        reject(new Error(`Script execution timed out after ${timeout}ms`))
-      }, timeout)
-    }
-
-    function onMessageReceived(message) {
-      if (message.contextId !== contextId) return
-
-      if (LOG._debug)
-        LOG.debug(`Post message received on main thread (code-ext/execute.js) from worker thread`, message)
-
-      switch (message.kind) {
-        case 'run':
-          run(message)
-          return
-
-        case 'success':
-          onSuccess(message)
-          return
-
-        case 'error':
-          onError(message.error)
-          return
-
-        // no default
-      }
-    }
-
-    async function onSuccess(message) {
-      for (const m of message.postMessages) await run(m)
-      req.data && Object.assign(req.data, message.req.data) // REVISIT: Why Object.assign(...) is a required?
-      req.results = message.req.results
-      cleanup()
-      resolve(req.results ?? message.result)
-    }
-
-    function onError(error) {
-      cleanup()
-      reject(error)
-    }
-
-    function onExit(exitCode) {
-      if (exitCode !== 0) {
-        reject(new Error(`Worker thread stopped with exit code ${exitCode}`))
-      }
-    }
-
-    async function run(message) {
-      try {
-        let result = _getTarget(message.target)[message.prop](...message.args)
-        if (typeof result?.then === 'function') result = await result
-        if (message.responseData) worker.postMessage({ id: message.id, kind: 'responseData', result })
-      } catch (error) {
-        if (LOG._debug) LOG.debug(`Calling ${message.target}.${message.prop}(...) throws an error.`, error)
-        if (message.id) worker.postMessage({ id: message.id, kind: 'cleanup' })
-        cleanup()
-        reject(error)
-      }
-    }
-
-    function cleanup() {
-      clearTimeout(onStartTimeoutID)
-      worker.removeListener('message', onMessageReceivedProxy)
-      worker.removeListener('error', onErrorProxy)
-      worker.removeListener('exit', onExitProxy)
-      workerPool.release(worker)
-    }
-  })
-
-  // triggers execution of the code in the worker thread
-  const message = { contextId, workerId, kind: 'start', code, reqData }
-  worker.postMessage(message)
-  return executePromise
-}

package/libx/_runtime/common/code-ext/handlers.js

@@ -1,50 +0,0 @@
-const cds = require('../../cds')
-const LOG = cds.log()
-const executeCode = require('./execute')
-const CODE_ANNOTATION = '@extension.code'
-
-module.exports = cds.service.impl(function () {
-  const getCodeFromAnnotation = async (defName, operation, registration) => {
-    // REVISIT: tenant info in not in this.model and cds.context.model is undefined for single tenancy
-    const model = cds.context.model || this.model
-    const el = model.definitions[defName]
-    const boundEl = el.actions?.[operation]
-    const extensionCode = boundEl?.[CODE_ANNOTATION] ?? el[CODE_ANNOTATION]
-    if (extensionCode) {
-      const annotation = extensionCode.filter(element => element[registration] === operation)
-      return annotation.length && annotation[0].code
-    }
-  }
-
-  this.after('READ', async function (result, req) {
-    if (result == null) return // whether result is null or undefined
-    const code = await getCodeFromAnnotation(req.target.name, req.event, 'after')
-    if (!code) return
-    await executeCode.call(this, code, req).catch(error => LOG._debug && LOG.debug(error))
-  })
-
-  this.before(['CREATE', 'UPDATE', 'DELETE'], async function (req) {
-    const code = await getCodeFromAnnotation(req.target.name, req.event, 'before')
-    if (!code) return
-    await executeCode.call(this, code, req).catch(error => LOG._debug && LOG.debug(error))
-  })
-
-  this.on('*', async function (req, next) {
-    if (this.name.startsWith('cds.xt')) return next()
-
-    // REVISIT: req.target -> wait until implementation task finished
-    let fqn = req.target?.actions?.[`${req.event}`] // check for bound action/function
-    if (!fqn) {
-      if (req.target) return next()
-      fqn = this.model.definitions[`${this.name}.${req.event}`] // check for bound action/function or event
-    }
-
-    // REVISIT: DO NOT OVERWRITE EXISTING Action Implementations!
-    // REVISIT: check whether action/function or event is part of an extension
-    if (fqn.kind === 'action' || fqn.kind === 'function' || req.constructor.name === 'EventMessage') {
-      const code = await getCodeFromAnnotation(req?.target?.name ?? fqn.name, req.event, 'on')
-      if (!code) return next()
-      return await executeCode.call(this, code, req).catch(error => LOG._debug && LOG.debug(error))
-    }
-  })
-})

package/libx/_runtime/common/code-ext/worker.js

@@ -1,70 +0,0 @@
-const cds = require('../../cds')
-const LOG = cds.log()
-const { parentPort, workerData } = require('worker_threads')
-const queryExecutor = require('./workerQueryExecutor')
-const WorkerReq = require('./WorkerReq')
-const { timeout } = require('./config')
-
-parentPort.on('message', function onWorkerMessageReceived(message) {
-  const { contextId, workerId, kind, code, reqData } = message
-  if (kind !== 'start' || workerId !== workerData.id) return
-  if (LOG._debug) LOG.debug(`Post message received on worker thread (worker.js) from main thread`, message)
-
-  const { VM } = require('vm2')
-  const workerReq = new WorkerReq(contextId, reqData)
-
-  class WorkerSELECT extends SELECT.class {
-    then(r, e) {
-      return new Promise(queryExecutor.bind(this, contextId)).then(r, e)
-    }
-  }
-
-  class WorkerINSERT extends INSERT.class {
-    then(r, e) {
-      return new Promise(queryExecutor.bind(this, contextId)).then(r, e)
-    }
-  }
-
-  class WorkerUPSERT extends UPSERT.class {
-    then(r, e) {
-      return new Promise(queryExecutor.bind(this, contextId)).then(r, e)
-    }
-  }
-
-  class WorkerUPDATE extends UPDATE.class {
-    then(r, e) {
-      return new Promise(queryExecutor.bind(this, contextId)).then(r, e)
-    }
-  }
-
-  class WorkerDELETE extends DELETE.class {
-    then(r, e) {
-      return new Promise(queryExecutor.bind(this, contextId)).then(r, e)
-    }
-  }
-
-  const vm = new VM({
-    console: 'inherit',
-    timeout, // specifies the number of milliseconds to execute code before terminating execution
-    allowAsync: true,
-
-    // the sandbox represents the global object inside the vm instance
-    sandbox: {
-      req: workerReq,
-      SELECT: WorkerSELECT._api(),
-      INSERT: WorkerINSERT._api(),
-      UPSERT: WorkerUPSERT._api(),
-      UPDATE: WorkerUPDATE._api(),
-      DELETE: WorkerDELETE._api()
-    }
-  })
-
-  try {
-    ;(async function () {
-      const result = await vm.run(code)
-      parentPort.postMessage({ contextId, kind: 'success', req: reqData, postMessages: workerReq.postMessages, result })
-    })()
-  } catch (error) {
-    parentPort.postMessage({ contextId, kind: 'error', error })
-  }
-})

package/libx/_runtime/common/code-ext/workerQueryExecutor.js

@@ -1,37 +0,0 @@
-const cds = require('../../cds')
-const LOG = cds.log()
-const { parentPort } = require('worker_threads')
-const executionContextMap = new Map()
-
-parentPort.on('message', function onWorkerMessageReceived(message) {
-  const { id, kind, result } = message
-  if (!executionContextMap.has(id)) return
-  if (LOG._debug) LOG.debug(`Post message received on worker thread (workerQueryExecutor.js) from main thread`, message)
-
-  switch (kind) {
-    case 'responseData':
-      executionContextMap.get(id)(result)
-      executionContextMap.delete(id)
-      return
-
-    case 'cleanup':
-      executionContextMap.delete(id)
-      return
-  }
-})
-
-function queryExecutor(contextId, resolve) {
-  const id = cds.utils.uuid()
-  executionContextMap.set(id, result => resolve(result))
-  parentPort.postMessage({
-    id,
-    contextId,
-    kind: 'run',
-    target: 'srv',
-    prop: 'run',
-    responseData: true,
-    args: [this]
-  })
-}
-
-module.exports = queryExecutor