const cds = require('@sap/cds/lib')
const { expect } = cds.test
const { cdr } = cds.ql
const Foo = { name: 'Foo' }
const Books = { name: 'capire.bookshop.Books' }


const STAR = cdr ? '*' : { ref: ['*'] }
const skip = {to:{eql:()=>skip}}
const srv = new cds.Service
let cqn

expect.plain = (cqn) => !cqn.SELECT.one && !cqn.SELECT.distinct ? expect(cqn) : skip
expect.one = (cqn) => !cqn.SELECT.distinct ? expect(cqn) : skip

describe('cds.ql → cqn', () => {
  //

  for (let each of ['SELECT', 'SELECT one', 'SELECT distinct']) {
    let SELECT; beforeEach(()=> SELECT = (
      each === 'SELECT distinct' ? cds.ql.SELECT.distinct :
      each === 'SELECT one' ? cds.ql.SELECT.one :
      cds.ql.SELECT
    ))
  describe(`${each}...`, () => {

    test(`from Foo`, () => {
      expect(cqn = SELECT `from Foo`)
      .to.eql(SELECT.from `Foo`)
      .to.eql(SELECT.from('Foo'))
      .to.eql(SELECT.from(Foo))
      .to.eql(SELECT`Foo`)
      .to.eql(SELECT('Foo'))
      .to.eql(SELECT(Foo))
      expect.plain(cqn)
      .to.eql(CQL`SELECT from Foo`)
      .to.eql(srv.read `Foo`)
      .to.eql(srv.read('Foo'))
      .to.eql(srv.read(Foo))
      .to.eql({
        SELECT: { from: { ref: ['Foo'] } },
      })
    })

    if (each === 'SELECT')
    test('SELECT ( Foo )', () => {
      expect({
        SELECT: { from: { ref: ['Foo'] } },
      })
      .to.eql(CQL`SELECT from Foo`)
      .to.eql(SELECT(Foo))
    })

    if (each === 'SELECT')
    test('SELECT ( Foo ) .from ( Bar )', () => {

      expect({
        SELECT: { columns:[{ref:['Foo']}], from: { ref: ['Bar'] } },
      })
      .to.eql(CQL`SELECT Foo from Bar`)
      .to.eql(SELECT `Foo` .from `Bar`)
      .to.eql(SELECT `Foo` .from('Bar'))
      .to.eql(SELECT('Foo').from('Bar'))
      .to.eql(SELECT(['Foo']).from('Bar'))
      .to.eql(SELECT(['Foo']).from('Bar'))
      .to.eql(SELECT `Bar` .columns `Foo`)
      .to.eql(SELECT `Bar` .columns ('Foo'))
      .to.eql(SELECT `Bar` .columns (['Foo']))
      .to.eql(SELECT.from `Bar` .columns ('Foo'))
      .to.eql(SELECT.from `Bar` .columns (['Foo']))

      expect({
        SELECT: { columns:[
          {ref:['Foo']},
          {ref:['Boo']},
        ], from: { ref: ['Bar'] } },
      })
      .to.eql(CQL`SELECT Foo, Boo from Bar`)
      .to.eql(SELECT `Foo, Boo` .from `Bar`)
      .to.eql(SELECT `Foo, Boo` .from('Bar'))
      .to.eql(SELECT('Foo','Boo').from('Bar'))
      .to.eql(SELECT(['Foo','Boo']).from('Bar'))
      .to.eql(SELECT `Bar` .columns `Foo, Boo`)
      .to.eql(SELECT `Bar` .columns ('Foo','Boo'))
      .to.eql(SELECT `Bar` .columns (['Foo','Boo']))
      .to.eql(SELECT.from `Bar` .columns ('Foo','Boo'))
      .to.eql(SELECT.from `Bar` .columns (['Foo','Boo']))

      expect({
        SELECT: { columns:[
          {ref:['Foo']},
          {ref:['Boo']},
          {ref:['Moo']},
        ], from: { ref: ['Bar'] } },
      })
      .to.eql(CQL`SELECT Foo, Boo, Moo from Bar`)
      .to.eql(SELECT `Foo, Boo, Moo` .from `Bar`)
      .to.eql(SELECT `Foo, Boo, Moo` .from('Bar'))
      .to.eql(SELECT('Foo','Boo','Moo').from('Bar'))
      .to.eql(SELECT(['Foo','Boo','Moo']).from('Bar'))
      .to.eql(SELECT `Bar` .columns `Foo, Boo, Moo`)
      .to.eql(SELECT `Bar` .columns ('Foo','Boo','Moo'))
      .to.eql(SELECT `Bar` .columns (['Foo','Boo','Moo']))
      .to.eql(SELECT.from `Bar` .columns ('Foo','Boo','Moo'))
      .to.eql(SELECT.from `Bar` .columns (['Foo','Boo','Moo']))


      expect({
        SELECT: { one:true, columns:[{ref:['Foo']}], from: { ref: ['Bar'] } },
      })
      // .to.eql(CQL`SELECT one Foo from Bar`)
      .to.eql(SELECT.one `Foo` .from `Bar`)
      .to.eql(SELECT.one `Foo` .from('Bar'))
      .to.eql(SELECT.one('Foo').from('Bar'))
      .to.eql(SELECT.one(['Foo']).from('Bar'))
      .to.eql(SELECT.one(['Foo']).from('Bar'))
      .to.eql(SELECT.one('Bar',['Foo']))
      .to.eql(SELECT.one `Bar` .columns `Foo`)
      .to.eql(SELECT.one('Bar').columns('Foo'))
      .to.eql(SELECT.one('Bar').columns(['Foo']))
      .to.eql(SELECT.one.from('Bar',['Foo']))
      .to.eql(SELECT.one.from('Bar').columns('Foo'))
      .to.eql(SELECT.one.from('Bar').columns(['Foo']))

      expect({
        SELECT: { one:true, columns:[
          {ref:['Foo']},
          {ref:['Boo']},
        ], from: { ref: ['Bar'] } },
      })
      // .to.eql(CQL`SELECT Foo, Boo from Bar`)
      .to.eql(SELECT.one `Foo, Boo` .from `Bar`)
      .to.eql(SELECT.one `Foo, Boo` .from('Bar'))
      .to.eql(SELECT.one('Foo','Boo').from('Bar'))
      .to.eql(SELECT.one(['Foo','Boo']).from('Bar'))
      .to.eql(SELECT.one('Bar',['Foo','Boo']))
      .to.eql(SELECT.one `Bar` .columns `Foo, Boo`)
      .to.eql(SELECT.one('Bar').columns('Foo','Boo'))
      .to.eql(SELECT.one('Bar').columns(['Foo','Boo']))
      .to.eql(SELECT.one.from('Bar',['Foo','Boo']))
      .to.eql(SELECT.one.from('Bar').columns('Foo','Boo'))
      .to.eql(SELECT.one.from('Bar').columns(['Foo','Boo']))

      expect({
        SELECT: { one:true, columns:[
          {ref:['Foo']},
          {ref:['Boo']},
          {ref:['Moo']},
        ], from: { ref: ['Bar'] } },
      })
      // .to.eql(CQL`SELECT Foo, Boo, Moo from Bar`)
      .to.eql(SELECT.one `Foo, Boo, Moo` .from `Bar`)
      .to.eql(SELECT.one `Foo, Boo, Moo` .from('Bar'))
      .to.eql(SELECT.one('Foo','Boo','Moo').from('Bar'))
      .to.eql(SELECT.one(['Foo','Boo','Moo']).from('Bar'))
      .to.eql(SELECT.one('Bar',['Foo','Boo','Moo']))
      .to.eql(SELECT.one `Bar` .columns `Foo, Boo, Moo`)
      .to.eql(SELECT.one('Bar').columns('Foo','Boo','Moo'))
      .to.eql(SELECT.one('Bar').columns(['Foo','Boo','Moo']))
      .to.eql(SELECT.one.from('Bar',['Foo','Boo','Moo']))
      .to.eql(SELECT.one.from('Bar').columns('Foo','Boo','Moo'))
      .to.eql(SELECT.one.from('Bar').columns(['Foo','Boo','Moo']))

    })

    if (each === 'SELECT')
    test('from ( Foo )', () => {
      expect({
        SELECT: { from: {ref: [{ id:'Foo', where: [{val:11}] }] }}
      })
      .to.eql(srv.read`Foo[${11}]`)
      .to.eql(SELECT`Foo[${11}]`)

      expect((cqn = SELECT`from Foo[ID=11]`))
      .to.eql(SELECT`from Foo[ID=${11}]`)
      .to.eql(SELECT.from `Foo[ID=11]`)
      .to.eql(SELECT.from `Foo[ID=${11}]`)
      .to.eql(SELECT`Foo[ID=11]`)
      expect.plain(cqn)
      .to.eql(CQL`SELECT from Foo[ID=11]`)
      .to.eql(srv.read`Foo[ID=11]`)
      .to.eql({
        SELECT: { from: {
          ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }],
        }},
      })

      if (cdr) expect.plain (cqn)
      .to.eql(SELECT`Foo[ID=${11}]`)
      .to.eql(srv.read`Foo[ID=${11}]`)

      // Following implicitly resolve to SELECT.one
      expect(cqn = SELECT.from(Foo,11))
      .to.eql(SELECT.from(Foo,{ID:11}))
      .to.eql(SELECT.from(Foo).byKey(11))
      .to.eql(SELECT.from(Foo).byKey({ID:11}))
      if (cds.version >= '5.6.0') {
        expect.one(cqn)
        .to.eql({
          SELECT: {
            one: true,
            from: { ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }] },
          },
        })
      } else {
        expect.one(cqn)
        .to.eql({
          SELECT: {
            one: true,
            from: { ref: ['Foo'] },
            where: [{ ref: ['ID'] }, '=', { val: 11 }],
          },
        })
      }

    })

    test('from Foo {...}', () => {

      expect(cqn = SELECT `*,a,b as c` .from `Foo`)
      .to.eql(SELECT `*,a,b as c`. from(Foo))
      .to.eql(SELECT('*','a',{b:'c'}).from`Foo`)
      .to.eql(SELECT('*','a',{b:'c'}).from(Foo))
      .to.eql(SELECT(['*','a',{b:'c'}]).from(Foo))
      .to.eql(SELECT.columns('*','a',{b:'c'}).from(Foo))
      .to.eql(SELECT.columns(['*','a',{b:'c'}]).from(Foo))
      .to.eql(SELECT.columns((foo) => { foo`.*`, foo.a, foo.b`as c` }).from(Foo))
      .to.eql(SELECT.columns((foo) => { foo('*'), foo.a, foo.b.as('c') }).from(Foo))
      .to.eql(SELECT.from(Foo).columns('*','a',{b:'c'}))
      .to.eql(SELECT.from(Foo).columns(['*','a',{b:'c'}]))
      .to.eql(SELECT.from(Foo).columns((foo) => { foo`.*`, foo.a, foo.b`as c` }))
      .to.eql(SELECT.from(Foo).columns((foo) => { foo('*'), foo.a, foo.b.as('c') }))
      .to.eql(SELECT.from(Foo,['*','a',{b:'c'}]))
      .to.eql(SELECT.from(Foo, (foo) => { foo`.*`, foo.a, foo.b`as c` }))
      .to.eql(SELECT.from(Foo, (foo) => { foo('*'), foo.a, foo.b.as('c') }))

      expect.plain(cqn)
      .to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          columns: [ STAR, { ref: ['a'] }, { ref: ['b'], as: 'c' }],
        },
      })

      cdr && expect.plain(cqn)
      .to.eql(CQL`SELECT *,a,b as c from Foo`)
      .to.eql(CQL`SELECT from Foo {*,a,b as c}`)

      // Test combination with key as second argument to .from
      expect(cqn = SELECT.from(Foo, 11, ['a']))
      .to.eql(SELECT.from(Foo, 11, foo => foo.a))

      if (cds.version >= '5.6.0') {
        expect.one(cqn)
        .to.eql({
          SELECT: {
            one: true,
            from: { ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }]}] },
            columns: [{ ref: ['a'] }]
          },
        })
      } else {
        expect.one(cqn)
        .to.eql({
          SELECT: {
            one: true,
            from: { ref: ['Foo'] },
            columns: [{ ref: ['a'] }],
            where: [{ ref: ['ID'] }, '=', { val: 11 }],
          },
        })
      }

    })

    test('with nested expands', () => {
      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
      expect(cqn =
        SELECT.from (Foo, foo => {
          foo`*`, foo.x, foo.car`*`, foo.boo (b => {
            b`*`, b.moo.zoo(
              x => x.y.z
            )
          })
        })
      ).to.eql(
        SELECT.from (Foo, foo => {
          foo('*'), foo.x, foo.car('*'), foo.boo (b => {
            b('*'), b.moo.zoo(
              x => x.y.z
            )
          })
        })
      )

      expect.plain(cqn)
      .to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          columns: [
            STAR,
            { ref: ['x'] },
            { ref: ['car'], expand: ['*'] },
            {
              ref: ['boo'],
              expand: [ '*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
            },
          ],
        },
      })
    })


    test('with nested inlines', () => {
      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
      expect.plain(
        SELECT.from (Foo, foo => {
          foo.bar `*`,
          foo.bar `.*`, //> leading dot indicates inline
          foo.boo(_ => _.moo.zoo), //> underscore arg name indicates inline
          foo.boo(x => x.moo.zoo)
        })
      ).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          columns: [
            { ref: ['bar'], expand: ['*'] },
            { ref: ['bar'], inline: ['*'] },
            { ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
            { ref: ['boo'], expand: [{ ref: ['moo', 'zoo'] }] },
          ],
        },
      })
    })

  })}

  describe ('SELECT where...', ()=>{

    it('should correctly handle { ... and:{...} }', () => {
      expect(SELECT.from(Foo).where({ x: 1, and: { y: 2, or: { z: 3 } } })).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          where: cdr ? [
            { ref: ['x'] },
            '=',
            { val: 1 },
            'and',
            // '(',
            {xpr:[
              { ref: ['y'] },
              '=',
              { val: 2 },
              'or',
              { ref: ['z'] },
              '=',
              { val: 3 },
            ]},
            // ')',
          ] : [
            { ref: ['x'] },
            '=',
            { val: 1 },
            'and',
            '(',
            // {xpr:[
              { ref: ['y'] },
              '=',
              { val: 2 },
              'or',
              { ref: ['z'] },
              '=',
              { val: 3 },
            // ]},
            ')',
          ],
        },
      })
    })

    test ("where x='*'", ()=>{
      if (cdr)
      expect (SELECT.from(Foo).where({x:'*'}))
      .to.eql(SELECT.from(Foo).where("x='*'"))
      .to.eql(SELECT.from(Foo).where("x=",'*'))
      .to.eql(SELECT.from(Foo).where`x=${'*'}`)
      .to.eql(
        CQL`SELECT from Foo where x='*'`
      )
      if (cdr)
      expect (SELECT.from(Foo).where({x:['*',1]}))
      .to.eql(SELECT.from(Foo).where("x in ('*',1)"))
      .to.eql(SELECT.from(Foo).where("x in",['*',1]))
      .to.eql(SELECT.from(Foo).where`x in ${['*',1]}`)
      .to.eql(
        CQL`SELECT from Foo where x in ('*',1)`
      )
    })

    test ('where, and, or', ()=>{
      expect (
        SELECT.from(Foo).where({x:1,and:{y:2}})
      ).to.eql (
        CQL`SELECT from Foo where x=1 and y=2`
      ) .to.eql ({ SELECT: {
        from: {ref:['Foo']},
        where: [
          {ref:['x']}, '=', {val:1},
          'and',
          {ref:['y']}, '=', {val:2}
        ]
      }})

      expect (
        SELECT.from(Foo).where({x:1,or:{y:2}})
      ).to.eql (
        CQL`SELECT from Foo where x=1 or y=2`
      ).to.eql ({ SELECT: {
        from: {ref:['Foo']},
        where: [
          {ref:['x']}, '=', {val:1},
          'or',
          {ref:['y']}, '=', {val:2}
        ]
      }})

      expect (
        SELECT.from(Foo).where({x:1,and:{y:2}}).or({z:3})
      ).to.eql (
        CQL`SELECT from Foo where x=1 and y=2 or z=3`
      )

      if (cdr) expect (
        SELECT.from(Foo).where({x:1}).and({y:2,or:{z:3}})
      ).to.eql (
        CQL`SELECT from Foo where x=1 and ( y=2 or z=3 )`
      )

      if (cdr) expect (
        SELECT.from(Foo).where({1:1}).and({x:1,or:{x:2}}).and({y:2,or:{z:3}})
      ).to.eql (
        CQL`SELECT from Foo where 1=1 and ( x=1 or x=2 ) and ( y=2 or z=3 )`
      )

      if (cdr) expect (
        SELECT.from(Foo).where({x:1,or:{x:2}}).and({y:2,or:{z:3}})
      ).to.eql (
        CQL`SELECT from Foo where ( x=1 or x=2 ) and ( y=2 or z=3 )`
      )
    })

    test('where ({x:[undefined]})', () => {
      if (cdr) expect (
        SELECT.from(Foo).where({x:[undefined]})
      ).to.eql ({ SELECT: {
        from: {ref:['Foo']},
        where: [
          {ref:['x']},
          'in',
          { list: [ {val:undefined} ] }
        ]
      }})
    })

    test('where ( ... cql  |  {x:y} )', () => {
      const args = [`foo`, "'bar'", 3]
      const ID = 11

      // using simple predicate objects
      // (Note: this doesn't support paths in left-hand-sides, nor references in arrays)
      expect(
        SELECT.from(Foo).where({
          ID,
          args,
          and: { x: { like: '%x%' }, or: { y: { '>=': 9 } } },
        })
      ).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          where: cdr ? [
            { ref: ['ID'] },
            '=',
            { val: ID },
            'and',
            { ref: ['args'] },
            'in',
            { list: args.map(val => ({ val })) },
            'and',
            {
              xpr: [
                { ref: ['x'] },
                'like',
                { val: '%x%' },
                'or',
                { ref: ['y'] },
                '>=',
                { val: 9 },
              ]
            },
          ] : [
            { ref: ['ID'] },
            '=',
            { val: ID },
            'and',
            { ref: ['args'] },
            'in',
            { list: args.map(val => ({ val })) },
            'and',
            '(',
            { ref: ['x'] },
            'like',
            { val: '%x%' },
            'or',
            { ref: ['y'] },
            '>=',
            { val: 9 },
            ')',
          ],
        }
      })

      // using CQL fragments -> uses cds.parse.expr
      const is_v2 = !!cds.parse.expr('(1,2)').list
      if (is_v2) expect((cqn = CQL`SELECT from Foo where ID=11 and x in ( foo, 'bar', 3)`)).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          where: [
            { ref: ['ID'] },
            '=',
            { val: ID },
            'and',
            { ref: ['x'] },
            'in',
            {list:[
              { ref: ['foo'] },
              { val: 'bar' },
              { val: 3 },
            ]}
          ],
        },
      })
      else expect((cqn = CQL`SELECT from Foo where ID=11 and x in ( foo, 'bar', 3)`)).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
          where: [
            { ref: ['ID'] },
            '=',
            { val: ID },
            'and',
            { ref: ['x'] },
            'in',
            '(',
            { ref: ['foo'] },
            ',',
            { val: 'bar' },
            ',',
            { val: 3 },
            ')',
          ],
        },
      })

      if (!is_v2) expect(
        SELECT.from(Foo).where(`x=`, 1, `or y.z is null and (a>`, 2, `or b=`, 3, `)`)
      ).to.eql(CQL`SELECT from Foo where x=1 or y.z is null and (a>2 or b=3)`)

      expect(SELECT.from(Foo).where(`x between`, 1, `and`, 9)).to.eql(
        CQL`SELECT from Foo where x between 1 and 9`
      )
    })

    test('w/ sub selects', () => {
      // in where causes
      expect(SELECT.from(Foo).where({ x: SELECT('y').from('Bar') })).to.eql(
        CQL`SELECT from Foo where x in (SELECT y from Bar)`
      )

      // using query api
      expect(SELECT.from('Books').where(
        `author.name in`, SELECT('name').from('Authors'))).to.eql(CQL`SELECT from Books where author.name in (SELECT name from Authors)`
      )

      // in classical semi joins
      expect(
        SELECT('x').from(Foo) .where ( `exists`,
          SELECT(1).from('Bar') .where ({ y: { ref: ['x'] } })
        ) // prettier-ignore
      ).to.eql(CQL`SELECT x from Foo where exists (SELECT 1 from Bar where y=x)`)

      // in select clauses
      cqn = CQL`SELECT from Foo { x, (SELECT y from Bar) as y }`
      cds.version >= '3.33.3' &&
        expect(
          SELECT.from(Foo, (foo) => {
            foo.x, foo(SELECT.from('Bar', (b) => b.y)).as('y')
          })
        ).to.eql(cqn)
      cds.version >= '3.33.3' &&
        expect(
          SELECT.from(Foo, ['x', Object.assign(SELECT('y').from('Bar'), { as: 'y' })])
        ).to.eql(cqn)
    })

    test('w/ plain SQL', () => {
      expect(SELECT.from(Books) + 'WHERE ...').to.eql(
        'SELECT * FROM capire_bookshop_Books WHERE ...'
      )
    })

    it('should consistently handle *', () => {
      if (!cdr) return
      expect({
        SELECT: { from: { ref: ['Foo'] }, columns: ['*'] },
      })
      .to.eql(CQL`SELECT * from Foo`)
      .to.eql(CQL`SELECT from Foo{*}`)
      .to.eql(SELECT('*').from(Foo))
      .to.eql(SELECT.from(Foo,['*']))
    })

    it('should consistently handle lists', () => {
      if (!cdr) return
      const ID = 11,  args = [{ref:['foo']}, "bar", 3]
      const cqn = CQL`SELECT from Foo where ID=11 and x in (foo,'bar',3)`
      expect(SELECT.from(Foo).where`ID=${ID} and x in ${args}`).to.eql(cqn)
      expect(SELECT.from(Foo).where(`ID=`, ID, `and x in`, args)).to.eql(cqn)
      expect(SELECT.from(Foo).where({ ID, x:args })).to.eql(cqn)
    })

    //
  })

  describe(`INSERT...`, () => {
    test('entries ({a,b}, ...)', () => {
      const entries = [{ foo: 1 }, { boo: 2 }]
      expect(INSERT(...entries).into(Foo))
        .to.eql(INSERT(entries).into(Foo))
        .to.eql(INSERT.into(Foo).entries(...entries))
        .to.eql(INSERT.into(Foo).entries(entries))
        .to.eql({
          INSERT: { into: 'Foo', entries },
        })
    })

    test('rows ([1,2], ...)', () => {
      expect(
        INSERT.into(Foo)
          .columns('a', 'b')
          .rows([
            [1, 2],
            [3, 4],
          ])
      )
        .to.eql(INSERT.into(Foo).columns('a', 'b').rows([1, 2], [3, 4]))
        .to.eql({
          INSERT: {
            into: 'Foo',
            columns: ['a', 'b'],
            rows: [
              [1, 2],
              [3, 4],
            ],
          },
        })
    })

    test('values (1,2)', () => {
      expect(INSERT.into(Foo).columns('a', 'b').values([1, 2]))
        .to.eql(INSERT.into(Foo).columns('a', 'b').values(1, 2))
        .to.eql({
          INSERT: { into: 'Foo', columns: ['a', 'b'], values: [1, 2] },
        })
    })

    test('w/ plain SQL', () => {
      expect(INSERT.into(Books) + 'VALUES ...').to.eql(
        'INSERT INTO capire_bookshop_Books VALUES ...'
      )
    })
  })

  describe(`UPDATE...`, () => {
    test('entity (..., <key>)', () => {
      const cqnWhere = {
          UPDATE: {
            entity: 'capire.bookshop.Books',
            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
          },
        }
      expect(UPDATE(Books).where({ ID: 4711 }))
        .to.eql(UPDATE(Books).where(`ID=`, 4711))
        .to.eql(cqnWhere)

      const cqnKey = (cds.version >= '5.6.0') ?
        {
          UPDATE: {
            entity: { ref: [{ id: 'capire.bookshop.Books', where: [{ ref: ['ID'] }, '=', { val: 4711 }] }] }
          }
        }
        : cqnWhere
      expect(UPDATE(Books, 4711))
        .to.eql(UPDATE(Books, { ID: 4711 }))
        .to.eql(UPDATE(Books).byKey(4711))
        .to.eql(UPDATE(Books).byKey({ ID: 4711 }))
        .to.eql(UPDATE.entity(Books, 4711))
        .to.eql(UPDATE.entity(Books, { ID: 4711 }))
        // etc...
        .to.eql(cqnKey)
    })

    /*
    UPDATE.with allows to pass in plain data payloads, e.g. as obtained from REST clients.
    In addition, UPDATE.with supports specifying expressions, either in CQL fragements
    notation or as simple expression objects.

    UPDATE.data allows to pass in plain data payloads, e.g. as obtained from REST clients.
    The passed in object can be modified subsequently, e.g. by adding or modifying values
    before the query is finally executed.
    */
    test('with + data', () => {
      if (cds.version < '4.1.0') return
      const o = {}
      const q = UPDATE(Foo).data(o).with(`bar-=`, 22)
      o.foo = 11
      expect(q)
        .to.eql(UPDATE(Foo).with(`foo=`, 11, `bar-=`, 22))
        .to.eql(UPDATE(Foo).with({ foo: 11, bar: { '-=': 22 } }))
        .to.eql({
          UPDATE: {
            entity: 'Foo',
            data: { foo: 11 },
            with: {
              bar: { xpr: [{ ref: ['bar'] }, '-', { val: 22 }] },
            },
          },
        })

      // some more
      expect(UPDATE(Foo).with(`bar = coalesce(x,y), car = 'foo''s bar, car'`)).to.eql({
        UPDATE: {
          entity: 'Foo',
          data: {
            car: "foo's bar, car",
          },
          with: {
            bar: { func: 'coalesce', args: [{ ref: ['x'] }, { ref: ['y'] }] },
          },
        },
      })
    })

    test('w/ plain SQL', () => {
      expect(UPDATE(Books) + 'SET ...').to.eql('UPDATE capire_bookshop_Books SET ...')
    })
  })

  describe(`DELETE...`, () => {
    test('from (..., <key>)', () => {
      const cqnWhere = {
          DELETE: {
            from: 'capire.bookshop.Books',
            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
          },
        }
      expect(DELETE.from(Books).where({ ID: 4711 }))
        .to.eql(DELETE.from(Books).where(`ID=`, 4711))
        .to.eql(cqnWhere)
      const cqnKey = (cds.version >= '5.6.0') ?
        {
          DELETE: {
          from: { ref: [{ id: 'capire.bookshop.Books', where: [{ ref: ['ID'] }, '=', { val: 4711 }]}] }
          },
        } : cqnWhere

      expect(DELETE(Books, 4711))
        .to.eql(DELETE(Books, { ID: 4711 }))
        .to.eql(DELETE.from(Books, 4711))
        .to.eql(DELETE.from(Books, { ID: 4711 }))
        .to.eql(DELETE.from(Books).byKey(4711))
        .to.eql(DELETE.from(Books).byKey({ ID: 4711 }))
        .to.eql(cqnKey)
    })

    test('/w plain SQL', () => {
      expect(DELETE.from(Books) + 'WHERE ...').to.eql(
        'DELETE FROM capire_bookshop_Books WHERE ...'
      )
    })
  })

  describe(`cds.ql etc...`, () => {
    it('should keep null and undefined', () => {
      for (let each of [null, undefined]) {
        expect(SELECT.from(Foo).where({ ID: each })).to.eql({
          SELECT: {
            from: { ref: ['Foo'] },
            where: [{ ref: ['ID'] }, '=', { val: each }],
          },
        })
      }
    })
  })

  //
})