@sap/cds-dk 10.0.3 → 10.0.4

package/node_modules/@cap-js/sqlite/README.md

@@ -0,0 +1,34 @@
+# CDS database service for SQLite
+
+Welcome to the SQLite database service for [SAP Cloud Application Programming Model](https://cap.cloud.sap) Node.js, based on streamlined database architecture and [*better-sqlite* driver](https://www.npmjs.com/package/better-sqlite3).
+
+## Setup
+
+If you want to use SQLite for development, all you need to do is to install the database package, as follows
+
+```sh
+npm add @cap-js/sqlite -D
+```
+
+Learn more about setup and usage in the [respective database guide](https://cap.cloud.sap/docs/guides/databases/sqlite).
+
+## Support
+
+This project is open to feature requests/suggestions, bug reports etc. via [GitHub issues](https://github.com/cap-js/cds-dbs/issues).
+
+## Contribution
+
+Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](../CONTRIBUTING.md).
+
+## Versioning
+
+This library follows [Semantic Versioning](https://semver.org/).
+All notable changes are documented in [CHANGELOG.md](CHANGELOG.md).
+
+## Code of Conduct
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](../CODE_OF_CONDUCT.md) at all times.
+
+## Licensing
+
+Copyright 2024 SAP SE or an SAP affiliate company and cds-dbs contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/cds-dbs).

package/node_modules/@cap-js/sqlite/index.js

@@ -0,0 +1,2 @@
+module.exports = require('./lib/SQLiteService.js')
+

package/node_modules/@cap-js/sqlite/lib/SQLiteService.js

@@ -0,0 +1,324 @@
+const { SQLService } = require('@cap-js/db-service')
+const cds = require('@sap/cds/lib')
+let sqlite // sqlite driver is loaded on connect
+
+const $session = Symbol('dbc.session')
+const sessionVariableMap = require('./session.json')  // Adjust the path as necessary for your project
+const convStrm = require('stream/consumers')
+const { Readable } = require('stream')
+
+const keywords = cds.compiler.to.sql.sqlite.keywords
+// keywords come as array
+const sqliteKeywords = keywords.reduce((prev, curr) => {
+  prev[curr] = 1
+  return prev
+}, {})
+
+// define date and time functions in js to allow for throwing errors
+const isTime = /^\d{1,2}:\d{1,2}:\d{1,2}$/
+const hasTimezone = /([+-]\d{1,2}:?\d{0,2}|Z)$/
+const toDate = (d, allowTime = false) => {
+  const date = new Date(allowTime && isTime.test(d) ? `1970-01-01T${d}Z` : hasTimezone.test(d) ? d : d + 'Z')
+  if (Number.isNaN(date.getTime())) throw new Error(`Value does not contain a valid ${allowTime ? 'time' : 'date'} "${d}"`)
+  return date
+}
+
+
+class SQLiteService extends SQLService {
+
+  get factory() {
+    return {
+      options: this.options.pool || {},
+      create: async tenant => {
+        try {
+          if (!sqlite) loadSQLite(this.options.driver || this.options.credentials?.driver)
+          const database = this.url4(tenant)
+          const dbc = new sqlite(database, this.options.client || {})
+          await dbc.ready
+
+          const deterministic = { deterministic: true }
+          dbc.function('session_context', key => dbc[$session][key])
+          dbc.function('regexp', deterministic, (re, x) => (RegExp(re).test(x) ? 1 : 0))
+          dbc.function('ISO', deterministic, d => d && new Date(d).toISOString())
+          dbc.function('year', deterministic, d => d === null ? null : toDate(d).getUTCFullYear())
+          dbc.function('month', deterministic, d => d === null ? null : toDate(d).getUTCMonth() + 1)
+          dbc.function('day', deterministic, d => d === null ? null : toDate(d).getUTCDate())
+          dbc.function('hour', deterministic, d => d === null ? null : toDate(d, true).getUTCHours())
+          dbc.function('minute', deterministic, d => d === null ? null : toDate(d, true).getUTCMinutes())
+          dbc.function('second', deterministic, d => d === null ? null : toDate(d, true).getUTCSeconds())
+          if (database !== ':memory:') dbc.pragma?.('journal_mode = WAL') || dbc.exec('PRAGMA journal_mode = WAL')
+          return dbc
+        } catch (err) {
+          Promise.reject(err)
+          await new Promise(() => { })
+        }
+      },
+      destroy: dbc => dbc.close(),
+      validate: dbc => dbc.open,
+    }
+  }
+
+  url4(tenant) {
+    let { url, database: db = url } = this.options.credentials || this.options || {}
+    if (!db || db === ':memory:') return ':memory:'
+    if (tenant) db = db.replace(/\.(db|sqlite)$/, `-${tenant}.$1`)
+    return cds.utils.path.resolve(cds.root, db)
+  }
+
+  set(variables) {
+    const dbc = this.dbc || cds.error('Cannot set session context: No database connection')
+
+    // Enrich provided session context with aliases
+    for (const alias in sessionVariableMap) {
+      const name = sessionVariableMap[alias]
+      if (variables[name]) variables[alias] = variables[name]
+    }
+
+    if (!dbc[$session]) dbc[$session] = variables
+    else Object.assign(dbc[$session], variables)
+  }
+
+  release() {
+    this.dbc[$session] = undefined
+    return super.release()
+  }
+
+  prepare(sql) {
+    try {
+      const stmt = this.dbc.prepare(sql)
+      return {
+        run: (..._) => this._run(stmt, ..._),
+        get: (..._) => stmt.get(..._),
+        all: (..._) => stmt.all(..._),
+        stream: (..._) => this._allStream(stmt, ..._),
+      }
+    } catch (e) {
+      e.message += ' in:\n' + (e.query = sql)
+      throw e
+    }
+  }
+
+  async _run(stmt, binding_params) {
+    for (let i = 0; i < binding_params.length; i++) {
+      const val = binding_params[i]
+      if (val instanceof Readable) {
+        binding_params[i] = await convStrm[val.type === 'json' ? 'text' : 'buffer'](val)
+      }
+      if (Buffer.isBuffer(val)) {
+        binding_params[i] = Buffer.from(val.toString('base64'))
+      }
+    }
+    return stmt.run(binding_params)
+  }
+
+  async *_iteratorRaw(rs, one) {
+    const pageSize = (1 << 16)
+    // Allow for both array and iterator result sets
+    const first = Array.isArray(rs) ? { done: !rs[0], value: rs[0] } : rs.next()
+    if (first.done) {
+      yield one ? 'null' : '[]'
+      return
+    }
+    if (one) {
+      yield first.value[0]
+      // Close result set to release database connection
+      rs.return()
+      return
+    }
+
+    let buffer = '[' + first.value[0]
+    // Print first value as stand alone to prevent comma check inside the loop
+    for (const row of rs) {
+      buffer += `,${row[0]}`
+      if (buffer.length > pageSize) {
+        yield buffer
+        buffer = ''
+      }
+    }
+    buffer += ']'
+    yield buffer
+  }
+
+  async *_iteratorObjectMode(rs) {
+    for (const row of rs) {
+      yield JSON.parse(row[0])
+    }
+  }
+
+  async _allStream(stmt, binding_params, one, objectMode) {
+    stmt = stmt.iterate ? stmt : stmt.__proto__
+    stmt.raw?.(true)
+    const rs = stmt.iterate(binding_params)
+    const stream = Readable.from(objectMode ? this._iteratorObjectMode(rs) : this._iteratorRaw(rs, one), { objectMode })
+    const close = () => rs.return() // finish result set when closed early
+    stream.on('error', close)
+    stream.on('close', close)
+    return stream
+  }
+
+  pragma(pragma, options) {
+    if (!this.dbc) return this.begin('pragma').then(tx => {
+      try { return tx.pragma(pragma, options) }
+      finally { tx.release() }
+    })
+    return this.dbc.pragma(pragma, options)
+  }
+
+
+  exec(sql) {
+    return this.dbc.exec(sql)
+  }
+
+  _prepareStreams(values) {
+    let any
+    values.forEach((v, i) => {
+      if (v instanceof Readable) {
+        any = values[i] = convStrm.buffer(v)
+      }
+    })
+    return any ? Promise.all(values) : values
+  }
+
+  async onSIMPLE({ query, data }) {
+    const { sql, values } = this.cqn2sql(query, data)
+    let ps = await this.prepare(sql)
+    const vals = await this._prepareStreams(values)
+    const { changes } = await ps.run(vals)
+    return this._return_affected (changes)
+  }
+
+  onPlainSQL({ query, data }, next) {
+    if (typeof query === 'string') {
+      // REVISIT: this is a hack the target of $now might not be a timestamp or date time
+      // Add input converter to CURRENT_TIMESTAMP inside views using $now
+      if (/^CREATE VIEW.* CURRENT_TIMESTAMP[( ]/is.test(query)) {
+        query = query.replace(/CURRENT_TIMESTAMP/gi, "STRFTIME('%Y-%m-%dT%H:%M:%fZ','NOW')")
+      }
+    }
+    return super.onPlainSQL({ query, data }, next)
+  }
+
+  static CQN2SQL = class CQN2SQLite extends SQLService.CQN2SQL {
+    column_alias4(x, q) {
+      let alias = super.column_alias4(x, q)
+      if (alias) return alias
+      if (x.ref) {
+        let obm = q._orderByMap
+        if (!obm) {
+          Object.defineProperty(q, '_orderByMap', { value: (obm = {}) })
+          q.SELECT?.orderBy?.forEach(o => {
+            if (o.ref?.length === 1) obm[o.ref[0]] = o.ref[0]
+          })
+        }
+        return obm[x.ref.at(-1)]
+      }
+    }
+
+    val(v) {
+      if (typeof v.val === 'boolean') v.val = v.val ? 1 : 0
+      else if (Buffer.isBuffer(v.val)) v.val = v.val.toString('base64')
+      // intercept DateTime values and convert to Date objects to compare ISO Strings
+      else if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d{1,9})?(Z|[+-]\d{2}(:?\d{2})?)$/.test(v.val)) {
+        const date = new Date(v.val)
+        if (!Number.isNaN(date.getTime())) {
+          v.val = date
+        }
+      }
+      return super.val(v)
+    }
+
+    forUpdate() {
+      return ''
+    }
+
+    forShareLock() {
+      return ''
+    }
+
+    // Used for INSERT statements
+    static InputConverters = {
+      ...super.InputConverters,
+      // The following allows passing in ISO strings with non-zulu
+      // timezones and converts them into zulu dates and times
+      Date: e => e === '?' ? e : `strftime('%Y-%m-%d',${e})`,
+      Time: e => e === '?' ? e : `strftime('%H:%M:%S',${e})`,
+      // Both, DateTimes and Timestamps are canonicalized to ISO strings with
+      // ms precision to allow safe comparisons, also to query {val}s in where clauses
+      DateTime: e => e === '?' ? e : `ISO(${e})`,
+      Timestamp: e => e === '?' ? e : `ISO(${e})`,
+    }
+
+    static OutputConverters = {
+      ...super.OutputConverters,
+      // Structs and arrays are stored as JSON strings; the ->'$' unwraps them.
+      // Otherwise they would be added as strings to json_objects.
+      Association: expr => `${expr}->'$'`,
+      struct: expr => `${expr}->'$'`,
+      array: expr => `${expr}->'$'`,
+      // SQLite has no booleans so we need to convert 0 and 1
+      boolean:
+        cds.env.features.sql_simple_queries === 2
+          ? undefined
+          : expr => `CASE ${expr} when 1 then 'true' when 0 then 'false' END ->'$'`,
+      // DateTimes are returned without ms added by InputConverters
+      DateTime: e => `substr(${e},0,20)||'Z'`,
+      // Timestamps are returned with ms, as written by InputConverters.
+      // And as cds.builtin.classes.Timestamp inherits from DateTime we need
+      // to override the DateTime converter above
+      Timestamp: undefined,
+      // int64 is stored as native int64 for best comparison
+      // Reading int64 as string to not loose precision
+      Int64: cds.env.features.ieee754compatible ? expr => `CAST(${expr} as TEXT)` : undefined,
+      // REVISIT: always cast to string in next major
+      // Reading decimal as string to not loose precision
+      Decimal: cds.env.features.ieee754compatible
+        ? (expr, elem) =>
+            elem?.scale
+              ? `CASE WHEN ${expr} IS NULL THEN NULL ELSE format('%.${elem.scale}f', ${expr}) END`
+              : `CASE WHEN ${expr} IS NULL THEN NULL ELSE rtrim(rtrim(format('%.999f', ${expr}), '0'), '.') END`
+        : undefined,
+      // Binary is not allowed in json objects
+      Binary: expr => `${expr} || ''`,
+    }
+
+    // Used for SQL function expressions
+    static Functions = { ...super.Functions, ...require('./cql-functions') }
+
+    // Used for CREATE TABLE statements
+    static TypeMap = {
+      ...super.TypeMap,
+      Binary: e => `BINARY_BLOB(${e.length || 5000})`,
+      Date: () => 'DATE_TEXT',
+      Time: () => 'TIME_TEXT',
+      DateTime: () => 'DATETIME_TEXT',
+      Timestamp: () => 'TIMESTAMP_TEXT',
+      Map: () => 'JSON_TEXT',
+      Decimal: cds.env.requires.db?.decimal_affinity?.match(/^real$/i) ? () => 'REAL_DECIMAL' : undefined,
+    }
+
+    get is_distinct_from_() {
+      return 'is not'
+    }
+    get is_not_distinct_from_() {
+      return 'is'
+    }
+
+    static ReservedWords = { ...super.ReservedWords, ...sqliteKeywords }
+  }
+}
+
+function loadSQLite(driver) {
+  const drivers = {
+    node: './node-sqlite.js',
+    'better-sqlite3': 'better-sqlite3',
+    'sql.js': './sql.js.js',
+  }
+
+  if (driver) {
+    sqlite = require(drivers[driver])
+  } else {
+    sqlite = require(drivers.node)
+  }
+}
+
+module.exports = SQLiteService

package/node_modules/@cap-js/sqlite/lib/cql-functions.js

@@ -0,0 +1,160 @@
+'use strict'
+
+const StandardFunctions = {
+  // ==============================
+  // Date and Time Functions
+  // ==============================
+
+  /**
+   * Ensures ISO strings are returned for current timestamp
+   * @returns {string} - SQL statement
+   */
+  current_timestamp: () => 'ISO(current_timestamp)',
+
+  /**
+   * SQLite doesn't support arguments for current_date
+   * @returns {string} - SQL statement
+   */
+  current_date: () => 'current_date',
+
+  /**
+   * SQLite doesn't support arguments for current_time
+   * @returns {string} - SQL statement
+   */
+  current_time: () => 'current_time',
+
+  /**
+   * Generates SQL statement that produces the fractional seconds of a given timestamp
+   * @param {string} x - The timestamp input
+   * @returns {string} - SQL statement
+   */
+  fractionalseconds: x => `cast(substr(strftime('%f', ${x}), length(strftime('%f', ${x})) - 3) as REAL)`,
+
+  // ==============================
+  // String Functions
+  // ==============================
+
+  /**
+   * Generates SQL statement that produces a boolean value indicating whether the first string contains the second string
+   * @param  {...string} args - The strings to evaluate
+   * @returns {string} - SQL statement
+   */
+  contains: (...args) => `(ifnull(instr(${args}),0) > 0)`,
+
+  /**
+   * Generates SQL statement that produces the index of the first occurrence of the second string in the first string
+   * @param {string} x - The string to search
+   * @param {string} y - The substring to find
+   * @returns {string} - SQL statement
+   */
+  indexof: (x, y) => `instr(${x},${y}) - 1`,
+
+  /**
+   * Generates SQL statement that produces a boolean value indicating whether the first string starts with the second string
+   * @param {string} x - The string to evaluate
+   * @param {string} y - The prefix to check
+   * @returns {string} - SQL statement
+   */
+  startswith: (x, y) => `coalesce(instr(${x},${y}) = 1,false)`,
+
+  /**
+   * Generates SQL statement that produces a boolean value indicating whether the first string ends with the second string
+   * @param {string} x - The string to evaluate
+   * @param {string} y - The suffix to check
+   * @returns {string} - SQL statement
+   */
+  endswith: (x, y) => `coalesce(substr(${x}, length(${x}) + 1 - length(${y})) = ${y},false)`,
+
+  /**
+   * Generates SQL statement that matches the given string against a regular expression
+   * @param {string} x - The string to match
+   * @param {string} y - The regular expression
+   * @returns {string} - SQL statement
+   */
+  matchesPattern: (x, y) => `(${x} regexp ${y})`,
+
+  /**
+   * Alias for matchesPattern
+   * @param {string} x - The string to match
+   * @param {string} y - The regular expression
+   * @returns {string} - SQL statement
+   */
+  matchespattern: (x, y) => `(${x} regexp ${y})`,
+}
+
+const HANAFunctions = {
+  // ==============================
+  // Timestamp Difference Functions
+  // ==============================
+
+  /**
+   * Generates SQL statement that calculates the difference in 100-nanoseconds between two timestamps
+   * @param {string} x - Left timestamp
+   * @param {string} y - Right timestamp
+   * @returns {string} - SQL statement
+   */
+  nano100_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 864000000000`,
+
+  /**
+   * Generates SQL statement that calculates the difference in seconds between two timestamps
+   * @param {string} x - Left timestamp
+   * @param {string} y - Right timestamp
+   * @returns {string} - SQL statement
+   */
+  seconds_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 86400`,
+
+  /**
+   * Generates SQL statement that calculates the difference in days between two timestamps
+   * @param {string} x - Left timestamp
+   * @param {string} y - Right timestamp
+   * @returns {string} - SQL statement
+   */
+  days_between: (x, y) => `(
+    cast(julianday(${y}) as Integer) - cast(julianday(${x}) as Integer)
+  ) + (
+    case
+      when (julianday(${y}) < julianday(${x})) then
+        (cast(strftime('%H%M%S%f0000', ${y}) as Integer) < cast(strftime('%H%M%S%f0000', ${x}) as Integer))
+      else
+        (cast(strftime('%H%M%S%f0000', ${y}) as Integer) > cast(strftime('%H%M%S%f0000', ${x}) as Integer)) * -1
+    end
+  )`,
+
+  /**
+   * Generates SQL statement that calculates the difference in months between two timestamps
+   * @param {string} x - Left timestamp
+   * @param {string} y - Right timestamp
+   * @returns {string} - SQL statement
+   */
+  months_between: (x, y) => `
+  (
+    (
+      (cast(strftime('%Y', ${y}) as Integer) - cast(strftime('%Y', ${x}) as Integer)) * 12
+    ) + (
+      cast(strftime('%m', ${y}) as Integer) - cast(strftime('%m', ${x}) as Integer)
+    ) + (
+      (
+        case
+          when (cast(strftime('%Y%m', ${y}) as Integer) < cast(strftime('%Y%m', ${x}) as Integer)) then
+            (cast(strftime('%d%H%M%S%f0000', ${y}) as Integer) > cast(strftime('%d%H%M%S%f0000', ${x}) as Integer))
+          else
+            (cast(strftime('%d%H%M%S%f0000', ${y}) as Integer) < cast(strftime('%d%H%M%S%f0000', ${x}) as Integer)) * -1
+        end
+      )
+    )
+  )`,
+
+  /**
+   * Generates SQL statement that calculates the difference in years between two timestamps
+   * @param {string} x - Left timestamp
+   * @param {string} y - Right timestamp
+   * @returns {string} - SQL statement
+   */
+  years_between(x, y) {
+    return `floor(${this.expr({ func: 'months_between', args: [x, y] })} / 12)`
+  },
+}
+
+for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]
+
+module.exports = { ...StandardFunctions, ...HANAFunctions }

package/node_modules/@cap-js/sqlite/lib/node-sqlite.js

@@ -0,0 +1,36 @@
+const { DatabaseSync } = require('node:sqlite');
+
+class NodeSqlite extends DatabaseSync {
+  prepare(sql) {
+    const stmt = super.prepare(sql)
+    const ret = {
+      run(params) {
+        try {
+          params = Array.isArray(params) ? params : [params]
+          return stmt.run(...params)
+        } catch (err) {
+          if (err.message.indexOf('NOT NULL constraint failed:') === 0) {
+            err.code = 'SQLITE_CONSTRAINT_NOTNULL'
+          }
+          throw err
+        }
+      },
+      get(params) {
+        params = Array.isArray(params) ? params : [params]
+        return stmt.get(...params)
+      },
+      all(params) {
+        params = Array.isArray(params) ? params : [params]
+        return stmt.all(...params)
+      },
+      iterate(params) {
+        stmt.setReturnArrays(true)
+        params = Array.isArray(params) ? params : [params]
+        return stmt.iterate(...params)
+      }
+    }
+    return ret
+  }
+}
+
+module.exports = NodeSqlite

package/node_modules/@cap-js/sqlite/lib/session.json

@@ -0,0 +1,3 @@
+{
+  "$user": "$user.id"
+}

package/node_modules/@cap-js/sqlite/lib/sql.js.js

@@ -0,0 +1,99 @@
+const initSqlJs = require('sql.js');
+
+const init = initSqlJs({})
+
+class WasmSqlite {
+  constructor(/*database*/) {
+    // TODO: load / store database file contents
+    this.ready = init
+      .then(SQL => {
+        this.db = new SQL.Database()
+        // polyfill for missing or mismatched default sqlite3 math functions
+        this.db.create_function('ln', x => Math.log(x))
+        this.db.create_function('log', (x) => Math.log10(x))
+        this.db.create_function('log', (x, y) => Math.log(y) / Math.log(x))
+        this.db.create_function('mod', (x, y) => x % y)
+      })
+
+    this.memory = true
+    this.gc = new FinalizationRegistry(stmt => { stmt.free() })
+  }
+
+  prepare(sql) {
+    const stmt = this.db.prepare(sql)
+    const ret = {
+      run(params) {
+        try {
+          stmt.bind(params)
+          stmt.step()
+          const changes = stmt.db.getRowsModified(stmt)
+          const lastInsertRowid = stmt.db.exec('SELECT last_insert_rowid()')[0]?.values[0][0]
+          return { changes, lastInsertRowid }
+        } catch (err) {
+          if (err.message.indexOf('NOT NULL constraint failed:') === 0) {
+            err.code = 'SQLITE_CONSTRAINT_NOTNULL'
+          }
+          throw err
+        }
+      },
+      get(params) {
+        const columns = stmt.getColumnNames()
+        stmt.bind(params)
+        stmt.step()
+        const row = stmt.get()
+        const ret = {}
+        for (let i = 0; i < columns.length; i++) {
+          ret[columns[i]] = row[i]
+        }
+        return ret
+      },
+      all(params) {
+        const columns = stmt.getColumnNames()
+        const ret = []
+        stmt.bind(params)
+        while (stmt.step()) {
+          const row = stmt.get()
+          const obj = {}
+          for (let i = 0; i < columns.length; i++) {
+            obj[columns[i]] = row[i]
+          }
+          ret.push(obj)
+        }
+        return ret
+      },
+      *iterate(params) {
+        stmt.bind(params)
+        while (stmt.step()) {
+          yield stmt.get()
+        }
+      }
+    }
+    this.gc.register(ret, stmt)
+    return ret
+  }
+
+  exec(sql) {
+    try {
+      const { columns, values } = this.db.exec(sql)
+      return !Array.isArray(values) ? values : values.map(val => {
+        const ret = {}
+        for (let i = 0; i < columns.length; i++) {
+          ret[columns[i]] = val[i]
+        }
+        return ret
+      })
+    } catch (err) {
+      // REVISIT: address transaction errors
+      if (sql === 'BEGIN' || sql === 'ROLLBACK') { return }
+      throw err
+    }
+  }
+
+  function(name, config, func) {
+    this.db.create_function(name, func || config)
+  }
+
+  close() { this.db.close() }
+}
+
+module.exports = WasmSqlite