@cap-js/db-service 1.0.0

package/lib/common/DatabaseService.js

@@ -0,0 +1,144 @@
+const infer = require('../infer')
+const cds = require('@sap/cds')
+
+function Pool(factory, tenant) {
+  const pool = createPool({ __proto__: factory, create: factory.create.bind(undefined, tenant) }, factory.options)
+  pool._trackedConnections = []
+  return pool
+}
+const { createPool } = require('@sap/cds-foss').pool
+
+class DatabaseService extends cds.Service {
+  /**
+   * Return a pool factory + options property as expected by
+   * https://github.com/coopernurse/node-pool#createpool.
+   */
+  get factory() {
+    throw '2b overriden in subclass'
+  }
+  pools = { _factory: this.factory }
+
+  get isMultitenant() {
+    return 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
+  }
+
+  /**
+   * Set one or more session context variables like so:
+   * ```js
+   * const tx = cds.db.tx()
+   * tx.set({
+   *   '$user.name': 'Alice',
+   *   '$user.role': 'admin'
+   * })
+   * ```
+   */
+  // eslint-disable-next-line no-unused-vars
+  set(variables) {
+    throw '2b overridden by subclass'
+  }
+
+  infer(q, m = this.model) {
+    return infer(q, m)
+  }
+
+  async begin() {
+    const ctx = this.context
+    if (!ctx) return this.tx().begin()
+    const tenant = this.isMultitenant && ctx.tenant
+    const pool = (this.pools[tenant] ??= new Pool(this.pools._factory, tenant))
+    const connections = pool._trackedConnections
+    let dbc
+    try {
+      dbc = this.dbc = await pool.acquire()
+    } catch (err) {
+      // TODO: add acquire timeout error check
+      err.stack += `\nActive connections:${connections.length}\n${connections.map(c => c._beginStack.stack).join('\n')}`
+      throw err
+    }
+    this._beginStack = new Error('begin called from:')
+    connections.push(this)
+    this._release = async dbc => {
+      await pool.release(dbc)
+      connections.splice(connections.indexOf(this), 1)
+    }
+    try {
+      // Setting session context variables
+      await this.set({
+        get '$user.id'() {
+          return _set(this, '$user.id', ctx.user?.id || 'anonymous')
+        },
+        get '$user.locale'() {
+          return _set(this, '$user.locale', ctx.locale || cds.env.i18n.default_language)
+        },
+        get '$valid.from'() {
+          return _set(this, '$valid.from', ctx._?.['VALID-FROM'] ?? ctx._?.['VALID-AT'] ?? '1970-01-01T00:00:00.000Z')
+        },
+        get '$valid.to'() {
+          return _set(
+            this,
+            '$valid.to',
+            ctx._?.['VALID-TO'] ?? _validTo4(ctx._?.['VALID-AT']) ?? '9999-11-11T22:22:22.000Z',
+          )
+        },
+      })
+      // Run BEGIN
+      await this.send('BEGIN')
+    } catch (e) {
+      this._release(dbc)
+      throw e
+    }
+    return this
+  }
+
+  async commit() {
+    const dbc = this.dbc
+    if (!dbc) return
+    await this.send('COMMIT')
+    this._release(dbc) // only release on successful commit as otherwise released on rollback
+  }
+
+  async rollback() {
+    const dbc = this.dbc
+    if (!dbc) return
+    try {
+      await this.send('ROLLBACK')
+    } finally {
+      this._release(dbc)
+    }
+  }
+
+  // REVISIT: should happen automatically after a configurable time
+  async disconnect(tenant) {
+    const pool = this.pools[tenant]
+    if (pool) delete this.pools[tenant]
+    else return
+    await pool.drain()
+    await pool.clear()
+  }
+
+  run(query, data, ...etc) {
+    // Allow db.run('...',1,2,3,4)
+    if (data !== undefined && typeof query === 'string' && typeof data !== 'object') data = [data, ...etc]
+    return super.run(query, data)
+  }
+
+  url4(/*tenant*/) {
+    // eslint-disable-line no-unused-vars
+    let { url } = this.options?.credentials || this.options || {}
+    return url
+  }
+  getDbUrl(tenant) {
+    return this.url4(tenant)
+  } // REVISIT: Remove after cds v6.7
+}
+
+const _set = (context, variable, value) => {
+  Object.defineProperty(context, variable, { value, configurable: true })
+  return value
+}
+const _validTo4 = validAt => {
+  return validAt?.replace(/(\dZ?)$/, d => parseInt(d[0]) + 1 + d[1] || '')
+}
+
+DatabaseService.prototype.isDatabaseService = true
+module.exports = DatabaseService

package/lib/cql-functions.js

@@ -0,0 +1,148 @@
+const StandardFunctions = {
+  // OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
+
+  // String and Collection Functions
+  // length     : (x) => `length(${x})`,
+  search: function (ref, arg) {
+    if (!('val' in arg)) throw `SQLite only supports single value arguments for $search`
+    const refs = ref.list || [ref],
+      { toString } = ref
+    return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
+  },
+  concat: (...args) => args.join('||'),
+  contains: (...args) => `ifnull(instr(${args}),0)`,
+  count: x => `count(${x || '*'})`,
+  countdistinct: x => `count(distinct ${x || '*'})`,
+  indexof: (x, y) => `instr(${x},${y}) - 1`, // sqlite instr is 1 indexed
+  startswith: (x, y) => `instr(${x},${y}) = 1`, // sqlite instr is 1 indexed
+  // takes the end of the string of the size of the target and compares it with the target
+  endswith: (x, y) => `substr(${x}, length(${x}) + 1 - length(${y})) = ${y}`,
+  substring: (x, y, z) =>
+    z
+      ? `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end, ${z} )`
+      : `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end )`,
+
+  // String Functions
+  matchesPattern: (x, y) => `${x} regexp ${y})`,
+  tolower: x => `lower(${x})`,
+  toupper: x => `upper(${x})`,
+  // trim           : (x) => `trim(${x})`,
+
+  // Arithmetic Functions
+  ceiling: x => `ceil(${x})`,
+  // floor    : (x) => `floor(${x})`,
+  // round    : (x) => `round(${x})`,
+
+  // Date and Time Functions
+  year: x => `cast( strftime('%Y',${x}) as Integer )`,
+  month: x => `cast( strftime('%m',${x}) as Integer )`,
+  day: x => `cast( strftime('%d',${x}) as Integer )`,
+  hour: x => `cast( strftime('%H',${x}) as Integer )`,
+  minute: x => `cast( strftime('%M',${x}) as Integer )`,
+  second: x => `cast( strftime('%S',${x}) as Integer )`,
+
+  fractionalseconds: x => `cast( strftime('%f0000',${x}) as Integer )`,
+
+  maxdatetime: () => '9999-12-31 23:59:59.999',
+  mindatetime: () => '0001-01-01 00:00:00.000',
+
+  // odata spec defines the date time offset type as a normal ISO time stamp
+  // Where the timezone can either be 'Z' (for UTC) or [+|-]xx:xx for the time offset
+  // sqlite understands this so by splitting the timezone from the actual date
+  // prefixing it with 1970 it allows sqlite to give back the number of seconds
+  // which can be divided by 60 back to minutes
+  totaloffsetminutes: x => `case
+    when substr(${x}, length(${x})) = 'z' then 0
+    else strftime('%s', '1970-01-01T00:00:00' || substr(${x}, length(${x}) - 5)) / 60
+  end`,
+
+  // odata spec defines the value format for totalseconds as a duration like: P12DT23H59M59.999999999999S
+  // P -> duration indicator
+  // D -> days, T -> Time seperator, H -> hours, M -> minutes, S -> fractional seconds
+  // By splitting the DT and calculating the seconds of the time separate from the day
+  // it possible to determine the full amount of seconds by adding them together as fractionals and multiplying
+  // the number of seconds in a day
+  // As sqlite is most accurate with juliandays it is better to do then then using actual second function
+  // while the odata specification states that the seconds has to be fractional which only julianday allows
+  totalseconds: x => `(
+    (
+      (
+        cast(substr(${x},2,instr(${x},'DT') - 2) as Integer)
+      ) + (
+        julianday(
+          '-4713-11-25T' ||
+          replace(
+          replace(
+          replace(
+            substr(${x},instr(${x},'DT') + 2),
+            'H',':'
+          ),'M',':'
+          ),'S','Z'
+          )
+        ) - 0.5
+      )
+    ) * 86400
+  )`,
+}
+
+const HANAFunctions = {
+  // https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/f12b86a6284c4aeeb449e57eb5dd3ebd.html
+
+  // Time functions
+  nano100_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 864000000000`,
+  seconds_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 86400`,
+  // Calculates the difference in full days using julian day
+  // Using the exact time of the day to determine whether 24 hours have passed or not to add the final day
+  // When just comparing the julianday values with each other there are leap seconds included
+  // Which on the day resolution are included as the individual days therefor ignoring them to match HANA
+  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
+  )`,
+
+  // (y1 - y0) * 12 + (m1 - m0) + (t1 < t0) * -1
+  /* '%d%H%M%S%f' returns as a number like which results in an equal check to:
+  (
+    d1 < d0 ||
+    (d1 = d0 && h1 < h0) ||
+    (d1 = d0 && h1 = h0 && m1 < m0) ||
+    (d1 = d0 && h1 = h0 && m1 = m0 && s1 < s0) ||
+    (d1 = d0 && h1 = h0 && m1 = m0 && s1 = s0 && ms1 < ms0)
+  )
+  Which will remove the current month if the time of the month is below the time of the month of the start date
+  It should not matter that the number of days in the month is different as for a month to have passed
+  the time of the month would have to be higher then the time of the month of the start date
+
+  Also check whether the result will be positive or negative to make sure to not subtract an extra month
+  */
+  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
+      )
+    )
+  )`,
+  years_between(x, y) {
+    return `floor(${this.months_between(x, y)} / 12)`
+  },
+}
+
+for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]
+
+module.exports = { ...StandardFunctions, ...HANAFunctions }