@cap-js/sqlite 0.1.0 → 1.0.0

package/cds.js

@@ -1,39 +0,0 @@
-const cds = module.exports = require('@sap/cds/lib')
-const { extend, lazified } = cds
-
-extend(cds).with(lazified({
-  inferred: lazy => require('./lib/ql/cds.infer'),
-  cqn2sql: lazy => require('./lib/db/sql/cqn2sql'),
-  cqn4sql: lazy => require('./lib/db/sql/cqn4sql'),
-}))
-
-extend (cds.ql.Query) .with (class {
-  forSQL (db = cds.db || cds) { return this.flat(db.cqn4sql(this)) }
-  toSQL  (db = cds.db || cds) { return _2sql(db.cqn2sql(this)) }
-  toSql  (db = cds.db || cds) { return this.toSQL(db).sql }
-})
-
-// Monkey-patch req.event to be undefined for plain sql query strings -> remove when @sap/cds 6.6 is released
-const $super = Reflect.getOwnPropertyDescriptor(cds.Request.prototype,'event')
-Reflect.defineProperty (cds.Request.prototype,'event', {...$super, get(){
-  if (typeof this.query === 'string') return this._set ('event', undefined)
-  else return $super.get.call(this)
-}})
-
-// skip .cqn property when in repl
-const _2sql = cds.repl ? ({sql,values}) => ({sql,values}) : x => x
-
-cds.ApplicationService // FIXME: somehow we need to invoke the getter, must be removed in the future
-
-// cds.requires.kinds.postgres = {
-//   kind: 'postgres',
-//   dialect: 'plain',
-//   credentials: {
-//     "host": "localhost",
-//     "port": "5432",
-//     "database": "beershop", //> override per test
-//     "username": "postgres",
-//     "password": "postgres"
-//   },
-//   impl: __dirname + '/lib/db/pg'
-// }

package/lib/db/DatabaseService.js

@@ -1,101 +0,0 @@
-const cds = require('../../cds')
-
-function Pool (factory, tenant) { return createPool (
-  { __proto__:factory, create: factory.create.bind(undefined,tenant) },
-  factory.options
-)}
-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 cds.inferred(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 dbc = this.dbc = await pool.acquire()
-    this._release = (dbc) => pool.release(dbc)
-    // 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:00Z') },
-      get '$valid.to'(){ return _set (this, '$valid.to', ctx._?.['VALID-TO'] || _validTo4(ctx._?.['VALID-AT']) || '9999-11-11T22:22:22Z') },
-    })
-    // Run BEGIN
-    try { 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/db/sql/InsertResults.js

@@ -1,87 +0,0 @@
-const iterator = Symbol.iterator
-
-// eslint-disable-next-line no-unused-vars
-const USAGE_SAMPLE = async ()=>{ // from https://pages.github.tools.sap/cap/docs/node.js/services?q=Emily#srvrun--query--results
-  const { Authors, Books } = {}
-  const [ Emily, Charlotte ] = await INSERT.into (Authors, [
-    { name: 'Emily Brontëe' },
-    { name: 'Charlotte Brontëe' },
-  ])
-  await INSERT.into (Books, [
-    { title: 'Wuthering Heights', author: Emily },
-    { title: 'Jane Eyre', author: Charlotte },
-  ])
-}
-
-
-module.exports = class InsertResult {
-
-  constructor (query, results) {
-    this.query = query
-    this.results = results
-  }
-
-  /*
-   * Lazy access to auto-generated keys.
-   */
-  get [iterator]() {
-
-    // For INSERT.as(SELECT.from(...)) return a dummy iterator with correct length
-    const { INSERT } = this.query
-    if (INSERT.as) {
-      return super[iterator] = function*(){
-        for (let i = 0; i < this.affectedRows; i++) yield {}
-      }
-    }
-
-    const { target } = this.query; if (!target?.keys) return (super[iterator] = this.results[iterator])
-    const keys = Object.keys(target.keys), [k1] = keys
-
-    // For INSERT.entries() with generated keys in there return these keys
-    const { entries } = INSERT; if (entries && k1 in entries[0]) {
-      return super[iterator] = function*(){
-        for (const each of entries)
-          yield keys.reduce ((p,k) => { p[k] = each[k]; return p },{})
-      }
-    }
-
-    // For INSERT.rows/values() with generated keys in there return these keys
-    const { columns } = INSERT; if (columns && columns.includes(k1)) {
-      return super[iterator] = function*(){
-        const indices = keys.reduce ((p,k) => {
-          let i = columns.indexOf(k); if (i >= 0) p[k] = i
-          return p
-        },{})
-        for (const each of INSERT.rows || [INSERT.values])
-          yield keys.reduce ((p,k) => { p[k] = each[indices[k]]; return p },{})
-      }
-    }
-
-    // If no generated keys in entries/rows/values we might have database-generated keys
-    const rows = this.results.slice(0, this.affectedRows) // only up to # of root entries
-    return super[iterator] = function*(){
-      for (const each of rows)
-        yield { [k1]: this.insertedRowId4(each) } // REVISIT: sqlite only returns a single lastID per row -> how is that with others?
-    }
-  }
-
-  /*
-   * the number of inserted (root) entries or the number of affectedRows in case of INSERT into SELECT
-   */
-  get affectedRows() {
-    const { INSERT:_ } = this.query
-    if (_.as) return super.affectedRows = this.affectedRows4(this.results[0]|| this.results)
-    else return super.affectedRows = _.entries?.length || _.rows?.length || this.results.length || 1
-  }
-
-  /*
-   * for checks such as res > 2
-   */
-  valueOf() {
-    return this.affectedRows
-  }
-
-  insertedRowId4 (result) { return result.lastID }
-  affectedRows4 (result) { return result.changes }
-
-}

package/lib/db/sql/SQLService.js

@@ -1,223 +0,0 @@
-const cds = require('../../../cds'), DEBUG = cds.debug('sql|db')
-const DatabaseService = require('../DatabaseService')
-const cqn4sql = require('./cqn4sql')
-const { target_name4 } = require('./utils')
-const { PassThrough, pipeline } = require('stream')
-
-
-class SQLService extends DatabaseService {
-
-  init() {
-    this.on([ 'INSERT', 'UPSERT', 'UPDATE', 'DELETE' ], require('./workarounds').input) // REVISIT should be replaced by correct input processing eventually
-    this.on([ 'INSERT', 'UPSERT', 'UPDATE', 'DELETE' ], require('./deep').onDeep)
-    this.on([ 'SELECT' ], this.onSELECT)
-    this.on([ 'INSERT', 'UPSERT' ], this.onINSERT)
-    this.on([ 'UPDATE' ], this.onUPDATE)
-    this.on([ 'DELETE', 'CREATE ENTITY', 'DROP ENTITY' ], this.onSIMPLE)
-    this.on([ 'BEGIN', 'COMMIT', 'ROLLBACK' ], this.onEVENT)
-    this.on([ '*' ], this.onPlainSQL)
-    return super.init()
-  }
-  
-  /** Handler for SELECT */
-  async onSELECT ({ query, data }) {
-    // REVISIT: disable this for queries like (SELECT 1)
-    // Will return multiple rows with objects inside
-    // REVISIT: streaming: if we need custom app and db handlers with app stream and cds.stream 
-    if (query._streaming) return this.onStream(query) // TODO: implemented on HANA
-    query.SELECT.expand = 'root'
-    const { sql, values, cqn } = this.cqn2sql (query, data)
-    let ps = await this.prepare(sql)
-    let rows = await ps.all(values)
-    if (rows.length)
-      if (cqn.SELECT.expand) rows = rows.map(r => typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r)
-    if (cqn.SELECT.count) rows.$count = await this.count(query, rows)
-    return cqn.SELECT.one || query.SELECT.from.ref?.[0].cardinality?.max === 1 ? rows[0] || null : rows
-  }
-
-  /** Handler for INSERT & UPSERT, which support bulk queries */
-  async onINSERT ({ query, data }) {
-    const { sql, entries, cqn } = this.cqn2sql (query, data)
-    if(!sql) return // Do nothing when there is nothing to be done
-    const ps = await this.prepare(sql)
-    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
-    return new this.class.InsertResults (cqn, results)
-  }
-
-  /** Handler for UPDATE */
-  async onUPDATE (req) {
-    return this.onSIMPLE(req)
-  }
-
-  /** Handler for CREATE, DROP, UPDATE, DELETE, with simple CQN */
-  async onSIMPLE ({ query, data }) {
-    const { sql, values } = this.cqn2sql (query, data)
-    let ps = await this.prepare(sql)
-    return (await ps.run(values)).changes
-  }
-
-  /** Handler for BEGIN, COMMIT, ROLLBACK, which don't have any CQN */
-  async onEVENT ({ event }) {
-    DEBUG?.(event) // in the other cases above DEBUG happens in cqn2sql
-    return await this.exec(event)
-  }
-
-  /** Handler for SQL statements which don't have any CQN */
-  async onPlainSQL ({ query, data }, next) {
-    if (typeof query === 'string') {
-      DEBUG?.(query)
-      const ps = await this.prepare(query)
-      const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
-      if (Array.isArray(data) && typeof data[0] === 'object')
-        return await Promise.all(data.map(exec))
-      else return exec(data)
-    }
-    else return next()
-  }
-
-  /** Override in subclasses to detect more statements to be called with ps.all() */
-  hasResults(sql) {
-    return /^(SELECT|WITH|CALL|PRAGMA table_info)/.test(sql)
-  }
-
-
-  /** Derives and executes a query to fill in `$count` for given query */
-  async count (query, ret) {
-    if (ret) {
-      const { one, limit:_ } = query.SELECT, n = ret.length
-      const [ max, offset=0 ] = one ? [1] : _ ? [ _.rows?.val, _.offset?.val ] : []
-      if (max === undefined || n < max && (n || !offset)) return n + offset
-    }
-    const cq = cds.ql.clone (query, {
-      columns: [{func:'count'}],
-      localized: false,
-      expand: false,
-      limit: 0,
-      orderBy: 0
-    })
-    const { sql, values } = this.cqn2sql(cq)
-    const ps = await this.prepare(sql)
-    const { count } = await ps.get(values)
-    return count
-  }
-
- /**
-   * Streaming
-   * Returns either a readable stream for sync calls or a readable stream promise for async calls 
-   */
-  stream(q) {
-    return typeof q === 'object' 
-    // aynchronous API: cds.stream(query)
-    ? this.run(Object.assign(q, { _streaming: true }))
-    // synchronous API: cds.stream('column').from(entity).where(...)
-    : new StreamCQN(q, this)
-  }
-
-
-  static InsertResults = require('./InsertResults')
-
-  /**
-   * Helper class implementing {@link SQLService#cqn2sql}.
-   * Subclasses commonly override this.
-   */
-  static CQN2SQL = require('./cqn2sql').class
-  constructor() {
-    super(...arguments)
-    this.class = new.target // for IntelliSense
-  }
-  cqn2sql(q,values) {
-    const cqn = this.cqn4sql(q)
-    return (new this.class.CQN2SQL) .render (cqn, values)
-  }
-  cqn4sql(q) {
-    if (!this.model?.definitions[target_name4(q)]) return _unquirked(q)
-    return cqn4sql (q, this.model)
-  }
-
-  /**
-   * Returns a Promise which resolves to a prepared statement object with
-   * `{run,get,all}` signature as specified in {@link PreparedStatement}.
-   * @returns {PreparedStatement}
-   */
-  // eslint-disable-next-line no-unused-vars
-  async prepare (sql) { throw '2b overridden by subclass' }
-
-  /**
-   * Used to execute simple SQL statement like BEGIN, COMMIT, ROLLBACK
-   */
-  // eslint-disable-next-line no-unused-vars
-  async exec (sql) { throw '2b overridden by subclass' }
-
-}
-
-
-/** Interface of prepared statement objects as returned by {@link SQLService#prepare} */
-class PreparedStatement { // eslint-disable-line no-unused-vars
-  /**
-   * Executes a prepared DML query, i.e., INSERT, UPDATE, DELETE, CREATE, DROP
-   * @param {[]|{}} binding_params
-   */
-  async run (binding_params) {} // eslint-disable-line no-unused-vars
-  /**
-   * Executes a prepared SELECT query and returns a single/first row only
-   * @param {[]|{}} binding_params
-   */
-  async get (binding_params) { return {} } // eslint-disable-line no-unused-vars
-  /**
-   * Executes a prepared SELECT query and returns an array of all rows
-   * @param {[]|{}} binding_params
-   */
-  async all (binding_params) { return [{}] } // eslint-disable-line no-unused-vars
-}
-
-/**
-   * Class that builds and runs stream CQN
-*/
-class StreamCQN { 
-  constructor (column, srv) {
-    this.column = column
-    this.srv = srv
-    this.result = new PassThrough() 
-  }
- /** synchronous streaming API: returns readable stream or class instance for chaining */
- from (...args) {  
-  this.sq = SELECT.from(...args)
-  this.sq._streaming = true
-  if (this.column) this.sq.columns([this.column]) 
-  const ref = this.sq.SELECT.from.ref     
-  if (!ref?.[ref.length - 1].where) return this
-  this._runStream()
-  return this.result
-} 
-/** synchronous streaming API: returns readable stream */
- where (...args) {             
-  this.sq.where(...args)
-  this._runStream()
-  return this.result 
-} 
-
- async _runStream() {
-  try {
-    const stream = await this.srv.run(this.sq)
-    // In case of streaming error while streaming from stream to this.result 
-    // the error is emitted to both streams. After this the output stream this.result is destroyed.
-    // No explicit closing of this.result is needed. 
-    // In (theoretical) case if for some error this.result is not destroyed the code like below can be used
-    // as callback: err => err && this.result.push(null)
-    stream ? pipeline(stream, this.result, () => {}) : this.result.push(null)
-  }
-  catch (err) { this.result.emit('error', err); this.result.push(null) } 
-}
-}
-
-const _unquirked = q => {
-  if (typeof q.INSERT?.into === 'string') q.INSERT.into = {ref:[q.INSERT.into]}
-  if (typeof q.UPSERT?.into === 'string') q.UPSERT.into = {ref:[q.UPSERT.into]}
-  if (typeof q.UPDATE?.entity === 'string') q.UPDATE.entity = {ref:[q.UPDATE.entity]}
-  if (typeof q.DELETE?.from === 'string') q.DELETE.from = {ref:[q.DELETE.from]}
-  if (typeof q.CREATE?.entity === 'string') q.CREATE.entity = {ref:[q.CREATE.entity]}
-  if (typeof q.DROP?.entity === 'string') q.DROP.entity = {ref:[q.DROP.entity]}
-  return q
-}
-
-module.exports = SQLService

package/lib/db/sql/copy.js

@@ -1,17 +0,0 @@
-module.exports.copy = function (obj) {
-  const walk = function (par, prop) {
-    const val = prop ? par[prop] : par
-
-    // If value is native return
-    if (typeof val !== 'object' || val == null || val instanceof RegExp || val instanceof Date || val instanceof Buffer)
-      return val
-
-    const ret = Array.isArray(val) ? [] : {}
-    Object.keys(val).forEach(k => {
-      ret[k] = walk(val, k)
-    })
-    return ret
-  }
-
-  return walk(obj)
-}