@cap-js/sqlite 0.2.0 → 1.0.1

package/lib/db/sqlite/SQLiteService.js

@@ -1,175 +0,0 @@
-const SQLService = require('../sql/SQLService')
-const sqlite = require('better-sqlite3')
-const cds = require ('@sap/cds/lib')
-const $session = Symbol('dbc.session')
-const { Readable } = require('stream')
-
-class SQLiteService extends SQLService {
-
-  get factory() { return {
-    options: { max:1, ...this.options.pool },
-    create: tenant => {
-      const database = this.url4(tenant)
-      const dbc = new sqlite (database)
-      dbc.function('SESSION_CONTEXT', key => dbc[$session][key])
-      dbc.function('REGEXP', { deterministic: true }, (re, x) => (RegExp(re).test(x) ? 1 : 0))
-      if (!dbc.memory) dbc.pragma('journal_mode = WAL')
-      return dbc
-    },
-    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')
-    if (!dbc[$session]) {
-      dbc[$session] = variables // initial call from within this.begin()
-      const $super = this._release; this._release = function (dbc) { // reset session on release
-        delete dbc[$session]
-        return $super.call(this,dbc)
-      }
-    }
-    else Object.assign (dbc[$session], variables) // subsequent uses from custom code
-  }
-
-  prepare (sql) {
-    try {
-      return this.dbc.prepare(sql)
-    } catch (e) {
-      e.message += ' in:\n'+ (e.sql = sql)
-      throw e
-    }
-  }
-
-  exec (sql) {
-    return this.dbc.exec(sql)
-  }
-
-  static CQN2SQL = class CQN2SQLite extends SQLService.CQN2SQL {
-
-    SELECT_columns({SELECT}) {
-      if (!SELECT.columns) return '*'
-      const { orderBy } = SELECT
-      const orderByMap = {}
-      // Collect all orderBy columns that should be taken from the SELECT.columns
-      if(Array.isArray(orderBy)) orderBy?.forEach(o => {
-        if(o.ref?.length === 1) {
-          orderByMap[o.ref[0]] = true
-        }
-      })
-      return SELECT.columns.map(x => {
-        const alias = this.column_name(x)
-        // Check whether the column alias should be added
-        const xpr = this.column_expr(x)
-        const needsAlias = (typeof x.as === 'string' && x.as) || orderByMap[alias]
-        return `${xpr}${needsAlias ? ` as ${this.quote(alias)}` : ''}`
-      })
-    }
-
-    operator (x,i,xpr) {
-      if (x === '=' && xpr[i+1]?.val === null) return 'is'
-      if (x === '!=') return 'is not'
-      else return x
-    }
-
-    // Used for INSERT statements
-    static InputConverters = { ...super.InputConverters,
-      Date:       e => `strftime('%Y-%m-%d',${e})`,
-      Time:       e => `strftime('%H:%M:%S',${e})`,
-      DateTime:   e => `strftime('%Y-%m-%dT%H:%M:%SZ',${e})`,
-      Timestamp:  e => `strftime('%Y-%m-%dT%H:%M:%fZ',${e})`,
-    }
-
-    static OutputConverters = { ...super.OutputConverters,
-      boolean: expr => `CASE ${expr} when 1 then 'true' when 0 then 'false' END ->'$'`, // REVIEW: ist that correct?
-      Int64:   expr => `CAST(${expr} as TEXT)`, // REVISIT: As discussed: please put that on a list of things to revisit later on
-      Decimal: expr => `nullif(quote(${expr}),'NULL')->'$'`, // REVISIT: what is that ->'$' doing?
-      Float:   expr => `nullif(quote(${expr}),'NULL')->'$'`,
-      Double:  expr => `nullif(quote(${expr}),'NULL')->'$'`,
-      struct:  expr => `${expr}->'$'`, // Association + Composition inherits from struct
-      array:   expr => `${expr}->'$'`,
-      // REVISIT: Timestamp should not loos precision
-      Date:       e => `strftime('%Y-%m-%d',${e})`,
-      Time:       e => `strftime('%H:%M:%S',${e})`,
-      DateTime:   e => `strftime('%Y-%m-%dT%H:%M:%SZ',${e})`,
-      Timestamp:  e => `strftime('%Y-%m-%dT%H:%M:%fZ',${e})`,
-    }
-
-    // Used for SQL function expressions
-    static Functions = { ...super.Functions }
-
-    // Used for CREATE TABLE statements
-    static TypeMap = { ...super.TypeMap,
-      Binary: e => `BINARY_BLOB(${e.length || 5000})`,
-      Date: () => 'DATE_TEXT',
-      Time: () => 'TIME_TEXT',
-      DateTime: () => 'TIMESTAMP_TEXT',
-      Timestamp: () => 'TIMESTAMP_TEXT'
-    }
-
-    static ReservedWords = { ...super.ReservedWords, ...require("./ReservedWords.json") }
-  }
-
-
-  // REALLY REVISIT: Here we are doing error handling which we probably never should have started.
-  // And worst of all, we handed out this as APIs without documenting it, so stakeholder tests rely
-  // on that? -> we urgently need to review these stakeholder tests.
-  // And we'd also need this to be implemented by each db service, and therefore documented, correct?
-  async onINSERT(req) {
-    try {
-      return await super.onINSERT(req)
-    } catch (err) {
-      throw _not_unique(err,'ENTITY_ALREADY_EXISTS')
-      || err
-    }
-  }
-
-  async onUPDATE(req) {
-    try {
-      return await super.onUPDATE(req)
-    } catch (err) {
-      throw _not_unique(err,'UNIQUE_CONSTRAINT_VIOLATION')
-      || err
-    }
-  }
-
-// SQLite doesn't support streaming, the whole data is read from the database 
-  async onStream(query) {
-    delete query._streaming
-    const result = await super.onSELECT({query, data: {}})
-    if (result == null || result.length === 0) return
-    let val = Array.isArray(result) ? Object.values(result[0])[0] : Object.values(result)[0]
-    if (val === null) return null
-    const stream_ = new Readable()
-    stream_.push(Buffer.from(val, 'base64'))
-    stream_.push(null)
-    return stream_
-  }
-
-}
-
-// function _not_null (err) {
-//   if (err.code === "SQLITE_CONSTRAINT_NOTNULL") return Object.assign ({
-//     code: 'MUST_NOT_BE_NULL',
-//     target: /\.(.*?)$/.exec(err.message)[1], // here we are even constructing OData responses, with .target
-//     message: 'Value is required',
-//   })
-// }
-
-function _not_unique (err, code) {
-  if (err.message.match(/unique constraint/i)) return Object.assign ({
-    originalMessage: err.message, // FIXME: required because of next line
-    message: code, // FIXME: misusing message as code
-    code: 400, // FIXME: misusing code as (http) status
-  })
-}
-
-module.exports = SQLiteService