@sap/cds 5.4.6 → 5.5.0

package/libx/_runtime/cds-services/statements/BaseStatement.js

@@ -1,72 +0,0 @@
-const cds = require('../../cds')
-
-const { invalidFunctionArgumentError } = require('../util/errors')
-
-const quotingStyles = require('../../common/utils/quotingStyles')
-
-const fnChain = Symbol.for('sap.cds.fnChain')
-
-const _resolveEntityAndKeys = pathExpression => {
-  return {
-    transformedEntity: `![${pathExpression.substring(0, pathExpression.indexOf('[')) || pathExpression}]`,
-    keys: pathExpression.substring(pathExpression.indexOf('['))
-  }
-}
-
-class BaseStatement {
-  constructor(dml) {
-    this[dml] = {}
-
-    Object.defineProperty(this, fnChain, { value: dml, writable: true })
-  }
-
-  static _isEntity(value, fnName) {
-    if (value) {
-      const entity = value.name || value
-
-      if (typeof entity === 'string') {
-        return entity
-      }
-    }
-
-    throw invalidFunctionArgumentError(fnName, value)
-  }
-
-  static convertPathExpression(entity) {
-    if (entity.includes(':') && entity.includes('[')) {
-      // if ']' included -> keys provided, ':' can be part of date key or navigationh
-      const baseEntity = entity.substring(0, entity.indexOf(']') + 1)
-      if (baseEntity.length === entity.length) {
-        // no navigation
-        const { transformedEntity, keys } = _resolveEntityAndKeys(baseEntity)
-        return cds.parse.expr(`${transformedEntity}${keys}`)
-      } else {
-        // ']' is followed by ':', we use + 1 to get the path
-        const path = entity.substring(baseEntity.length + 1, entity.length)
-        const { transformedEntity, keys } = _resolveEntityAndKeys(baseEntity)
-        return cds.parse.expr(`${transformedEntity}${keys}.${path}`)
-      }
-    }
-
-    if (entity.includes(':')) {
-      // if no ']' included -> no keys provided -> first ':' must be separator
-      const [baseEntity, path] = entity.split(/:(.+)/)
-      const { transformedEntity } = _resolveEntityAndKeys(baseEntity)
-      return cds.parse.expr(`${transformedEntity}.${path}`)
-    }
-
-    // entity.includes.only('['))
-    const { transformedEntity, keys } = _resolveEntityAndKeys(entity)
-    return cds.parse.expr(`${transformedEntity}${keys}`)
-  }
-
-  static _quoteElement(element) {
-    return quotingStyles[cds.env.sql.names || 'plain'](element)
-  }
-
-  get _isQuery() {
-    return true
-  }
-}
-
-module.exports = BaseStatement

package/libx/_runtime/cds-services/statements/Create.js

@@ -1,57 +0,0 @@
-const BaseStatement = require('./BaseStatement')
-const { hasBeenCalledError, invalidFunctionArgumentError } = require('../util/errors')
-
-const fnChain = Symbol.for('sap.cds.fnChain')
-
-/**
- * CREATE statement creates entity
- */
-class Create extends BaseStatement {
-  constructor() {
-    super('CREATE')
-  }
-
-  /**
-   * @param {string | object} entity - entity name or an entity from reflection API
-   * @param {object} elements - dictionary as specified in CSN element definition
-   */
-  static entity(entity, elements) {
-    BaseStatement._isEntity(entity, 'CREATE.entity()')
-
-    const cqn = new Create()
-    cqn[fnChain] = cqn[fnChain].concat('.entity()')
-
-    if (elements) {
-      cqn.CREATE.entity = { elements: elements, kind: 'entity', name: entity }
-    } else {
-      cqn.CREATE.entity = entity
-    }
-
-    return cqn
-  }
-
-  /**
-   * Constructs a create statement as SELECT.from statement
-   *
-   * @param {object} query - SELECT query
-   * @example
-   * CREATE.entity('Bar').as(SELECT.from('Foo'))
-   * @throws Error - if called twice or if query is not of expected format
-   *
-   */
-  as(query) {
-    this[fnChain] = this[fnChain].concat('.as()')
-    if (!query || !query.SELECT) {
-      throw invalidFunctionArgumentError(this[fnChain], query)
-    }
-
-    if (this.CREATE.as) {
-      throw hasBeenCalledError('as()', this[fnChain])
-    }
-
-    this.CREATE.as = query
-    return this
-  }
-}
-
-module.exports = Create

package/libx/_runtime/cds-services/statements/Delete.js

@@ -1,33 +0,0 @@
-const Where = require('./Where')
-
-/**
- * DELETE statement removes values or rows from a specific table.
- *
- * @extends {Where}
- */
-class Delete extends Where {
-  constructor() {
-    super('DELETE')
-  }
-
-  /**
-   * @param {string|object} entity string or an entity from reflection API
-   */
-  static from(entity) {
-    const cqn = new Delete()
-
-    if (typeof entity === 'string' && (entity.includes(':') || entity.includes('['))) {
-      cqn.DELETE.from = Where.convertPathExpression(entity)
-    } else {
-      cqn.DELETE.from = Where._isEntity(entity, 'DELETE.from()')
-    }
-
-    return cqn
-  }
-
-  valueOf() {
-    return `DELETE FROM ${Delete._quoteElement(this.DELETE.from)} `
-  }
-}
-
-module.exports = Delete

package/libx/_runtime/cds-services/statements/Drop.js

@@ -1,42 +0,0 @@
-/* istanbul ignore file */
-// REVISIT: why never used?!
-
-const BaseStatement = require('./BaseStatement')
-
-/**
- * DROP statement removes a specific table and or view.
- */
-class Drop extends BaseStatement {
-  constructor() {
-    super('DROP')
-  }
-
-  /**
-   * Drop table and or view for an entity.
-   *
-   * @param {string | object} entity - entity name or an entity from reflection API
-   */
-  static entity(entity) {
-    BaseStatement._isEntity(entity, 'DROP.entity()')
-    const cqn = new Drop()
-    cqn.DROP.entity = entity
-
-    return cqn
-  }
-
-  static table(entity) {
-    const cqn = Drop.entity(entity)
-    cqn.DROP.table = cqn.DROP.entity
-
-    return cqn
-  }
-
-  static view(entity) {
-    const cqn = Drop.entity(entity)
-    cqn.DROP.view = cqn.DROP.entity
-
-    return cqn
-  }
-}
-
-module.exports = Drop

package/libx/_runtime/cds-services/statements/Insert.js

@@ -1,201 +0,0 @@
-const BaseStatement = require('./BaseStatement')
-const { invalidFunctionArgumentError } = require('../util/errors')
-
-const fnChain = Symbol.for('sap.cds.fnChain')
-
-/**
- * Insert values into table
- */
-class Insert extends BaseStatement {
-  constructor() {
-    super('INSERT')
-  }
-
-  /**
-   * Name of the entity where the entries should be inserted
-   *
-   * @example <caption>In case the order of columns is known, their names can be omitted</caption>
-   * INSERT.into('Books')
-   *  .rows([1, 'Harry Potter'])
-   *
-   * @example <caption>In case the order of columns is unknown, specify the name of the columns</caption>
-   * INSERT.into('Books')
-   *  .columns('ID', 'NAME')
-   *  .rows([1, 'The Hitchhikers Guide to the Galaxy'])
-   *
-   * @example <caption>Use an object instead of array</caption>
-   * INSERT.into('Books')
-   *  .rows({ID:1, NAME: 'Animal Farm'})
-   *
-   * @param {string|object} entity string or an entity from reflection API
-   *
-   * @returns {Insert} CQN object for Insert
-   */
-  static into(entity) {
-    const cqn = new Insert()
-    cqn[fnChain] = cqn[fnChain].concat('.into()')
-
-    if (typeof entity === 'string' && (entity.includes(':') || entity.includes('['))) {
-      cqn.INSERT.into = BaseStatement.convertPathExpression(entity)
-    } else {
-      cqn.INSERT.into = BaseStatement._isEntity(entity, 'INSERT.into()')
-    }
-
-    return cqn
-  }
-
-  /**
-   * Optional. Can be used to order the value entries if column names are known
-   *
-   * @param {Array} columnNames - names of the columns
-   * @param {Array} args - List of columns in case one arguemnt per column is used
-   * @returns {Insert} current instance of the insert
-   * @throws Error if columnNames is neither String nor Array
-   */
-  columns(columnNames, ...args) {
-    this[fnChain] = this[fnChain].concat('.columns()')
-    if (typeof columnNames === 'string') {
-      args.unshift(columnNames)
-      columnNames = args
-    }
-
-    if (Array.isArray(columnNames)) {
-      this.INSERT.columns = columnNames
-      return this
-    }
-
-    throw invalidFunctionArgumentError(this[fnChain], columnNames)
-  }
-
-  /**
-   * Adds one or multiple rows to the table.
-   *
-   * @example <caption>In case the order of columns is known, their names can be omitted</caption>
-   * @param {...any} args
-   * INSERT.into('Books')
-   *   .rows([1, 'Harry Potter'])
-   *
-   * @example <caption>If order is unknown specify the name of the columns</caption>
-   * INSERT.into('Books')
-   *   .columns('ID', 'NAME')
-   *   .rows([1, 'The Hitchhikers Guide to the Galaxy'])
-   *
-   * @example <caption>Use an object instead of array</caption>
-   * INSERT.into('Books')
-   *   .rows({ID:1, NAME: 'Animal Farm'})
-   *
-   * @example <caption>Batch insert</caption>
-   * INSERT.into('Books').rows([
-   *   [1, 'Harry Potter'],
-   *   [2, 'The Hitchhikers Guide to the Galaxy'],
-   *   [3, 'Animal Farm']
-   * ])
-   * @example <caption>Batch insert with objects</caption>
-   * INSERT.into('Books').rows([
-   *   {ID:1, NAME: 'Harry Potter'},
-   *   {ID:2, NAME: 'The Hitchhikers Guide to the Galaxy'},
-   *   {ID:3, NAME: 'Animal Farm'}
-   * ])
-   *  @param {Array | object} rows
-   *  @returns {object} query object according to CQN format
-   *  @throws Error if no valid rows are provided
-   */
-  rows(rows, ...args) {
-    this[fnChain] = this[fnChain].concat('.rows()')
-    if (!rows) {
-      throw invalidFunctionArgumentError(this[fnChain])
-    }
-
-    if (Array.isArray(rows)) {
-      // check if we have at least one element
-      if (rows.length === 0) {
-        throw invalidFunctionArgumentError(this[fnChain], rows)
-      }
-
-      // check if all the entries in the array are arrays
-      if (rows.every(e => Array.isArray(e))) {
-        this._rows(rows)
-        // check if array contains one or multiple objects
-      } else if (rows.every(e => typeof e === 'object')) {
-        this._entries(rows)
-        // the rows have been added as arguments
-      } else if (args.length !== 0) {
-        args.unshift(rows)
-        this._rows(args)
-      } else {
-        this._values(rows)
-      }
-    } else if (typeof rows === 'object') {
-      this._entries(rows)
-    } else {
-      throw invalidFunctionArgumentError(this[fnChain], rows)
-    }
-
-    return this
-  }
-
-  /**
-   * Adds one or more entries as rows.
-   *
-   * @param {...any} args
-   * @throws Error if no valid entries are provided
-   */
-  entries(...args) {
-    this[fnChain] = this[fnChain].concat('.entries()')
-    const entries = Array.isArray(args[0]) ? args[0] : args
-    this._invalidArgs('entries', entries)
-    return this.rows(entries)
-  }
-
-  values(...args) {
-    this[fnChain] = this[fnChain].concat('.values()')
-    const values = Array.isArray(args[0]) ? args[0] : args
-    this._invalidArgs('values', values)
-    this._values(values)
-    return this
-  }
-
-  as(selectCqn) {
-    this[fnChain] = this[fnChain].concat('.as()')
-    if (!selectCqn || !selectCqn.SELECT) {
-      throw invalidFunctionArgumentError(this[fnChain], selectCqn)
-    }
-
-    this.INSERT.as = selectCqn
-    return this
-  }
-
-  _invalidArgs(argName, args) {
-    if (!Array.isArray(args) || args.length === 0) {
-      throw invalidFunctionArgumentError(this[fnChain], args)
-    }
-  }
-
-  _rows(rows) {
-    this.INSERT.rows = rows
-  }
-
-  _values(values) {
-    this.INSERT.values = values
-  }
-
-  _entries(entries) {
-    // object can be passed directly, so if only 1 object is passed wrap it into an array
-    this.INSERT.entries = Array.isArray(entries) ? entries : [entries]
-  }
-
-  valueOf() {
-    return `INSERT INTO ${Insert._quoteElement(this.INSERT.into)} `
-  }
-}
-
-const insert = (...entries) => {
-  return {
-    into: entity => {
-      return Insert.into(entity).entries(...entries)
-    }
-  }
-}
-insert.into = Insert.into
-
-module.exports = insert