@sap/cds-dk 9.9.3 → 10.0.4

package/node_modules/@sap/cds/lib/ql/cds.ql-Query.js

@@ -0,0 +1,111 @@
+const { AsyncResource } = require('async_hooks')
+const cds = require('../index')
+const cached = {}
+
+
+class Query {
+
+  static init() {
+    const self = this, kind = self.name
+    Object.defineProperty (this.prototype, 'kind', {value:kind})
+    Object.defineProperty (this, 'name', {value:'cds.ql'})
+    return Object.assign (function chimera (x,...etc) {
+      if (!new.target) return self.call (x,...etc)
+      let q = new self; if (x) q[kind] = x
+      return q
+    }, this.API)
+  }
+
+  /** @private to be implemented in subclassed*/
+  static call() {}
+
+
+  /**
+   * The kind of query, as in CQN's SELECT, INSERT, UPDATE, DELETE, CREATE, DROP.
+   */
+  get kind() { return this.constructor.name }
+
+
+  /**
+   * Note to self: We can't use .as (alias) as that would conflict with
+   * sub selects in columns, which in turn may has aliases in .as.
+   */
+  alias (a) {
+    this._subject.as = a
+    return this
+  }
+
+  /** Creates a derived instance that initially inherits all properties. */
+  clone (_) {
+    const kind = this.kind || Object.keys(this)[0]
+    return {__proto__:this, [kind]: {__proto__:this[kind],..._} }
+  }
+
+  flat (q=this) {
+    let x = q.kind || Object.keys(q)[0], y = q[x]
+    let protos = [y]; for (let o=y; o.__proto__;) protos.push (o = o.__proto__)
+    q[x] = Object.assign ({}, ...protos.reverse())
+    if (y.columns) for (let c of y.columns) if (c.SELECT) (this||Query.prototype).flat(c)
+    return q
+  }
+
+  /** Binds this query to be executed with the given service */
+  bind (srv) {
+    return Object.defineProperty (this,'_srv',{ value:srv, configurable:true, writable:true })
+  }
+
+  /** Turns all queries into Thenables which execute with primary db by default */
+  get then() {
+    const srv = this._srv || cds.db || cds.error `Can't execute query as no primary database is connected.`
+    const q = new AsyncResource('await cds.query')
+    return (r,e) => q.runInAsyncScope (srv.run, srv, this).then (r,e)
+  }
+
+  get _subject() { throw new Error('should be overridden in subclasses') }
+  set _target(t) { this._set('_target',t) } // ensure non-enumerable
+
+  /** @returns {ref:string[]} */
+  _target4 (x,...y) {
+    if (typeof x === 'string') {
+      const r = cached[x] ??= cds.parse.path(x); this._target = {name:r.ref[0]}
+      return { ...r, ref:[...r.ref] } // clone ref, as they may get modified
+    } else if (x) {
+      if (x.raw)    return this._target4 (y.length ? cds.parse.path(x,...y) : x[0])
+      if (x.ref)    return this._target = {name:x.ref[0]}, x
+      if (x.name)   return this._target = x, {ref:[x.name]}
+      if (x.SELECT) return this._target = x
+      if (x.SET)    return this._target = x
+    }
+    throw this._expected `${{target:x}} to be a CSN entity, an entity name or path, a {ref}, or a subquery`
+  }
+
+  _expected (...args) {
+    return cds.error.expected (...args)
+  }
+
+  _assign (...aspects) {
+    Object.assign (this[this.kind], ...aspects)
+    return this
+  }
+
+  _add (property, values) {
+    let $ = this[this.kind], former = $[property]
+    if (cds.env.features.compat_clone_appends && !Object.hasOwn($,property)) former = undefined
+    $[property] = !former ? values : [ ...former, ...values ]
+    return this
+  }
+
+  _set (property, value) {
+    Object.defineProperty (this, property, { value, configurable:true, writable:true })
+    return value
+  }
+
+  valueOf (prelude = this.kind) {
+    return `${prelude} ${_name(this._target.name)} `
+  }
+}
+
+const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
+const _no_target = ()=>{ throw cds.error `Queries don't have a 'target' property. Use 'req.target' instead.` }
+Object.defineProperty (Query.prototype, 'target', { get:_no_target, set:_no_target })
+module.exports = Query

package/node_modules/@sap/cds/lib/ql/cds.ql-infer.js

@@ -0,0 +1,148 @@
+/* eslint-disable no-useless-assignment */
+
+const cds = require('../index')
+const infer = exports = module.exports = (..._) => infer.target(..._)
+
+
+/**
+ * Infers the target entity of a query
+ * @param {import('./cds.ql-Query')} q
+ */
+infer.target = function (q, ctx) {
+  if (q._target instanceof cds.entity) return q._target //> already inferred
+  const subject = _subject4(q)
+  const target = (
+    subject?.SELECT ? infer.target (subject, ctx ??= _context4(q)) :
+    subject?.ref ? infer.ref (subject.ref, ctx ??= _context4(q)) :
+    undefined
+  )
+  Object.defineProperty (q, '_target', { value: target, configurable:true, writable:true })
+  return target
+}
+
+infer.ref = function (ref, ctx) {
+  const defs = (ctx.model||ctx).definitions
+  let name = _name4(ref[0]), d = defs?.[name] || ctx.entities?.[name]
+  if (!d) return { name, _unresolved:true, __proto__: cds.entity.prototype }
+  else for (let i=1; i < ref.length; ++i) {
+    d = d.elements?.[name = _name4(ref[i])] || cds.error `Element ${name} not found in ${d}`
+    if (d.target) d = defs[d.target] || cds.error `Target ${d.target} not found in ${defs}`
+  }
+  return d
+}
+
+/** @param {import('./SELECT').class} q */
+infer.elements = function (q) {
+
+  const subject = _subject4(q); if (!subject) return
+  const source = subject.SELECT ? cds.ql(subject) : infer.target(q)
+
+  return _infer_elements4 (source, q.SELECT.columns, q.SELECT.excluding, q.SELECT.from.as)
+  function _infer_elements4 (source, columns, excluding, alias) {
+
+    // SELECT from Books; SELECT * from Books
+    if (!columns || columns.length === 1 && columns[0] === '*')
+      if (!excluding) return source?.elements
+
+    const excludes = excluding?.reduce((p,n)=>(p[n]=1,p),{}) || {}
+    const elements = {}
+    columns.forEach (c => {
+
+      // 1) SELECT *, ... from Books
+      if (c === '*') {
+        for (let e in source.elements)
+          e in elements || e in excludes || (elements[e] = source.elements[e])
+        return
+      }
+
+      const ref = c.ref?.map(_name4); if (ref?.length > 1 && alias === ref[0]) ref.shift()
+      const as = c.as || ref?.join('_') || c.func || c.val || cds.error `Alias required for column expressions ${c}`
+      let d = source, is2many
+
+      // 2.1) SELECT ... : String from Books
+      if (c.cast) {
+        return elements[as] = builtin [c.cast.type]
+      }
+      // 2.2) SELECT cast (... as String) from Books
+      if (c.xpr?.[0]?.cast) {
+        return elements[as] = builtin [c.xpr[0].cast.type]
+      }
+
+      // 3) SELECT title, author.name, $user.id from Books
+      if (c.ref && d?.elements) {
+        if (ref[0] in $pseudos) { d = $pseudos[ref[0]]; ref.shift() }
+        for (let r of ref) d = (d.SELECT ? d : d._target||d).elements?.[r]
+          || cds.error `Couldn't resolve element "${ref.join('/')}" in ${source.kind} ${source.name||''} ${Object.keys(source.elements)}`
+        if (d._target) { is2many = d.is2many; c.expand || c.inline ? d = d._target : d }
+        // ... d is further processed in steps 5,6,7 below
+      }
+
+      // 4) SELECT 1, 2+3, count(*) from Books; SELECT type, name from sqlite.schema
+      else if (!c.expand) {
+        return elements[as] = _typeof(c)
+      }
+
+      // 5) SELECT author.books { title } from Books
+      if (c.expand) {
+        if (d.items) { d = d.items; is2many = true }
+        const nested = _infer_elements4 (d, c.expand, c.excluding)
+        const struct = new cds.struct ({ elements: nested })
+        return elements[as] = is2many ? new cds.array ({ items:struct }) : struct
+      }
+
+      // 6) SELECT author.books.{ title } from Books
+      if (c.inline) {
+        const nested = _infer_elements4 (d, c.inline, c.excluding)
+        for (let n in nested) elements[as+'_'+n] = nested[n]
+      }
+
+      // 7) SELECT title, author.name from Books
+      else return elements[as] = d // NOTE: the else is neccessary after step 5 above
+      // else return elements[as] = as === d.name ? d : { __proto__:d, name:as }
+    })
+    return elements
+  }
+}
+
+// REVISIT: should this prefer cds.context.model over q._srv?
+const _context4 = q => q._srv ?? cds.context?.model ?? cds.model ?? {}
+const _subject4 = q => q._subject
+  || q.SELECT?.from
+  || q.INSERT?.into
+  || q.UPSERT?.into
+  || q.UPDATE?.entity
+  || q.DELETE?.from
+
+const _name4 = r => r.id || r
+const _typeof = c => {
+  if (c.val !== undefined) return builtin [typeof c.val] || builtin [ Number.isInteger(c.val) ? 'Integer' : 'Decimal' ]
+  if (c.func === 'count') return builtin.Integer
+  if (c.xpr?.length === 1) return _typeof(c.xpr[0])
+  if (c.xpr) return { type: null }
+  return unknown
+}
+
+const unknown = exports.unknown = Object.freeze (new cds.type ({ _unresolved:true }))
+const builtin = function() {
+  const bi={}, bt = cds.builtin.types
+  for (let t of Object.keys(bt)) bi[t] = bi[t.slice(4)] = { type:t, __proto__: bt[t] }
+  bi.boolean = bi['cds.Boolean']
+  bi.string = bi['cds.String']
+  return bi
+}()
+
+const $pseudos = {
+  $user: { __proto__: builtin.String,
+    elements: {
+      id: builtin.String,
+      locale: builtin.String,
+      tenant: builtin.String
+    }
+  },
+  $now: builtin.Timestamp,
+  $at: builtin.Timestamp,
+  $from: builtin.Timestamp,
+  $to: builtin.Timestamp,
+  $locale: builtin.String,
+  $tenant: builtin.String,
+}

package/node_modules/@sap/cds/lib/ql/cds.ql-predicates.js

@@ -0,0 +1,136 @@
+const cds = require('../index')
+module.exports = predicate
+
+
+/** @import cqn from './cqn' */
+/** @returns {cqn.xo[]} */
+function predicate (...args) {
+  const [x] = args
+  if (x) switch (typeof x) {
+    case 'object':
+      if (x.raw) return _ttl(args)
+      if (args.length > 1) return _legacy(...args) //> legacy support for predicate (ref`a`, '=', val`b`)
+      if (is_array(x)) return x
+      if (is_cqn(x)) return [x]
+      else return _qbe(x)
+    case 'string': return _fluid(args)
+    default: return args.map(_val)
+  }
+}
+
+
+function _ttl (args) {
+  const cxn = cds.parse.expr(...args)
+  return cxn.xpr ?? [cxn] //> the fallback is for single-item exprs like `1` or `ref`
+}
+
+
+function _fluid (args) {
+  if (args.length === 3) switch (args[1]) {
+    case '=': case '<': case '<=': case '>': case '>=': case '!=': case '<>': case 'like': case 'in': case 'IN': case 'LIKE':
+      return _legacy (...args)
+  }
+  if (args.length % 2 === 0) args.push('')
+  const expr = args.filter((_, i) => i % 2 === 0).join(' ? ')
+  const vals = args.filter((_, i) => i % 2 === 1)
+  const { xpr } = _pred_expr(expr); (function _fill_in_vals_into (xpr) {
+    xpr.forEach((x, i) => {
+      if (x.xpr) _fill_in_vals_into(x.xpr)
+      if (x.param) xpr[i] = _val(vals.shift())
+    })
+  })(xpr)
+  return xpr
+}
+
+
+function _qbe (o, xpr=[]) {
+
+  let count = 0
+  for (let k in o) { const x = o[k]
+
+    if (k.startsWith('not ')) { xpr.push('not'); k = k.slice(4) }
+    switch (k) { // handle special cases like {and:{...}} or {or:{...}}
+      case 'between':
+        xpr.push('between', _val(x), 'and', _val(o.and))
+        return xpr
+      case 'and': xpr.push(k)
+        x.or ? xpr.push({xpr:_qbe(x)}) : _qbe(x,xpr)
+        continue
+      case 'or':  xpr.push(k)
+        _qbe(x,xpr)
+        continue
+      case 'not': 
+        if (count++) xpr.push('and')  //> add 'and' between conditions
+        xpr.push(k)
+        if (x && typeof x === 'object') x.in || x.like || x.exists || x.between ? _qbe(x,xpr) : xpr.push({xpr:_qbe(x)})
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'is': xpr.push('is')
+        if (x && typeof x === 'object') _qbe(x,xpr)
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'is not': xpr.push('is','not')
+        if (x && typeof x === 'object') _qbe(x,xpr)
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'exists':
+        if (count++) xpr.push('and')  //> add 'and' between conditions
+        xpr.push(k,_ref(x)||x)
+        continue
+      case 'in': case 'IN': // REVISIT: 'IN' is for compatibility only
+        xpr.push(k, x.SELECT ? x : { list: x.map(_val) })
+        continue
+      case '=': case '<': case '<=': case '>': case '>=': case '!=': case '<>': case 'like': case 'LIKE': // REVISIT: 'LIKE' is for compatibility only
+        xpr.push(k,_val(x))
+        continue
+    }
+
+    const a = cds.parse.ref(k)        //> turn key into a ref for the left side of the expression
+    if (count++) xpr.push('and')      //> add 'and' between conditions
+    if (!x || typeof x !== 'object')  xpr.push (a,'=',{val:x})
+    else if (is_array(x))             xpr.push (a,'in',{list:x.map(_val)})
+    else if (x.SELECT || x.list)      xpr.push (a,'in',x)
+    else if (is_cqn(x))               xpr.push (a,'=',x)
+    else if (x instanceof Date)       xpr.push (a,'=',{val:x})
+    else if (x instanceof Buffer)     xpr.push (a,'=',{val:x})
+    else if (x instanceof RegExp)     xpr.push (a,'like',{val:x})
+    else { xpr.push(a); _qbe(x,xpr) } //> recurse into nested qbe
+  }
+  return xpr
+}
+
+
+/** @deprecated */
+const _legacy = (x,o,y) => [ _ref(x)||x, o, _val(y) ]
+
+const _pred_expr = x => {
+  if (typeof x !== 'string') return {val:x}
+  if (x === '*') return x
+  const t = /^\s*([\w.'?]+)(?:\s*([!?\\/:=\-+<~>]+|like)\s*([\w.'?]+))?\s*$/.exec(x)
+  if (!t) return cds.parse.expr(x)
+  const [,lhs,op,rhs] = t
+  return !op ? _ref_or_val(lhs) : {xpr:[ _ref_or_val(lhs), op, _ref_or_val(rhs) ]}
+}
+
+const _ref_or_val = (x) => {
+  if (x[0] === '?')  return { param: true, ref: x }
+  if (x[0] === "'")  return { val: x.slice(1,-1).replace(/''/g, "'") }
+  if (x === 'null')  return { val: null }
+  if (x === 'true')  return { val: true }
+  if (x === 'false') return { val: false }
+  if (!isNaN(x))     return { val: Number(x) }
+  else               return { ref: x.split('.') }
+}
+
+const _ref = x => typeof x === 'string' ? { ref: x.split('.') } : x // if x is a string, turn it into a ref; if not we assume it's a cxn object
+const _val = x => !x ? {val:x} : is_array(x) ? { list: x.map(_val) } : is_cqn(x) ? x : {val:x}
+
+const is_cqn = x => typeof x === 'object' && (
+  'ref' in x ||
+  'val' in x ||
+  'xpr' in x ||
+  'list' in x ||
+  'func' in x ||
+  'SELECT' in x
+)
+const is_array = Array.isArray

package/node_modules/@sap/cds/lib/ql/cds.ql-projections.js

@@ -0,0 +1,111 @@
+const predicate = require('./cds.ql-predicates')
+const cds = require('../index')
+
+/** @import cqn from './cqn' */
+/** @returns {cqn.column[]} */
+module.exports = function projection (...args) {
+  const [x] = args
+  if (x) switch (typeof x) {
+    case 'function':
+      return _function(x)
+    case 'object':
+      if (x.raw) return _ttl(args)
+      if (is_array(x)) return _array(x)
+      break //> processing all args below
+    case 'string':
+      if (x[0] === '{') return _string(x)
+  }
+  return _array (args)
+}
+
+
+function _ttl (args) {
+  if (args[0][0][0] === '{') return cds.parse._select('from X',args).columns
+  return cds.parse._select('',args,'from X').columns
+}
+
+function _string (x) {
+  return cds.parse.cql('SELECT from X '+ x).SELECT.columns
+}
+
+
+function _array (args) {
+  return args.map (column_expr)
+  function column_expr (x) {
+    switch (typeof x) {
+      case 'string': {
+        if (x === '*') return x
+        let alias = /\s+as\s+(\w+)$/i.exec(x)
+        if (alias) return { ...cds.parse.ref(x.slice(0,alias.index)), as: alias[1] }
+        return cds.parse.ref(x)
+      }
+      case 'object': {
+        if (x.name) return { ref: [x.name] } //> reflected element
+        if (is_cqn(x)) return x //> already a CQN object
+        else for (let e in x) return {...cds.parse.ref(e), as: x[e] } //> { element: alias }
+        throw this._expected`Argument for SELECT.columns(${x}) to be a valid column expression`
+      }
+      default: return { val: x }
+    }
+  }
+}
+
+
+function _function (fn) {
+  const columns = []; fn(new Proxy(fn, {
+    apply: (_, __, args) => {
+      if (!args.length) return columns.push('*')
+      let [x] = is_array(args[0]) ? args[0] : args
+      columns.push(x === '*' || x === '.*' ? '*' : is_cqn(x) ? x : { ref: [x] })
+      return { as: (alias) => (x.as = alias) }
+    },
+    get: (_, p) => {
+      const col = { ref: [p] }; columns.push(col)
+      const nested = new Proxy(fn, {
+        get: (_, p) => {
+          if (p === 'where') return (x) => ((col.where = predicate(x)), nested)
+          if (p === 'as') return (alias) => ((col.as = alias), nested)
+          else return col.ref.push(p), nested
+        },
+        apply: (_, __, args) => {
+          const [a, b] = args
+          if (!a) col.expand = ['*']
+          else if (a.raw) switch (a[0]) {
+            case '*': col.expand = ['*']; break
+            case '.*': col.inline = ['*']; break
+            default: {
+              // The ttl is the tail of a column expression including infic filter and nested projection.
+              // So, we need to add the col name as prefix to be able to parse it...
+              const {columns} = cds.parse._select(col.ref.at(-1), args, 'from X')
+              Object.assign(col, columns[0])
+            }
+          }
+          else if (is_array(a)) col.expand = _array(a)
+          else if (a === '*') col.expand = ['*']
+          else if (a === '.*') col.inline = ['*']
+          else if (typeof a === 'string') col.ref.push(a)
+          else if (typeof a === 'function') {
+            let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = _function(a))
+            if (b?.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
+          } else if (typeof b === 'function') {
+            let x = (col[/^\(?_\b/.test(b) ? 'inline' : 'expand'] = _function(b))
+            if (a?.depth) while (--a.depth) x.push({ ...col, expand: (x = [...x]) })
+          }
+          return nested
+        },
+      })
+      return nested
+    },
+  }))
+  return columns
+}
+
+const is_cqn = x => typeof x === 'object' && (
+  'ref' in x ||
+  'val' in x ||
+  'xpr' in x ||
+  'list' in x ||
+  'func' in x ||
+  'SELECT' in x
+)
+const is_array = Array.isArray

package/node_modules/@sap/cds/lib/ql/cqn.d.ts

@@ -0,0 +1,146 @@
+/**
+ * `INSERT` and `UPSERT` queries are represented by the same internal
+ * structures. The `UPSERT` keyword is used to indicate that the
+ * statement should be updated if the targeted data exists.
+ * The `into` property specifies the target entity.
+ *
+ * The data to be inserted or updated can be specified in different ways:
+ *
+ * - in the `entries` property as deeply nested records.
+ * - in the `columns` and `values` properties as in SQL.
+ * - in the `columns` and `rows` properties, with `rows` being array of `values`.
+ * - in the `from` property with a `SELECT` query to provide the data to be inserted.
+ *
+ * The latter is the equivalent of SQL's `INSERT INTO ... SELECT ...` statements.
+ */
+export class INSERT { INSERT: UPSERT['UPSERT'] }
+export class UPSERT { UPSERT: {
+  into      : ref
+  entries?  : data[]
+  columns?  : string[]
+  values?   : scalar[]
+  rows?     : scalar[][]
+  from?     : SELECT
+}}
+
+
+/**
+ * `UPDATE` queries are used to capture modifications to existing data.
+ * They support a `where` clause to specify the rows to be updated,
+ * and a `with` clause to specify the new values. Alternatively, the
+ * `data` property can be used to specify updates with plain data only.
+ */
+export class UPDATE { UPDATE: {
+  entity  : ref
+  where?  : expr
+  data    : data
+  with    : changes
+}}
+
+
+/**
+ * `DELETE` queries are used to remove data from a target datasource.
+ * They support a `where` clause to specify the rows to be deleted.
+ */
+export class DELETE { DELETE: {
+  from    : ref
+  where?  : expr
+}}
+
+
+/**
+ * `SELECT` queries are used to retrieve data from a target datasource,
+ * and very much resemble SQL's `SELECT` statements, with these noteworthy
+ * additions:
+ *
+ * - The `from` clause supports `{ref}` paths with infix filters.
+ * - The `columns` clause supports deeply nested projections.
+ * - The `count` property requests the total count, similar to OData's `$count`.
+ * - The `one` property indicates that only a single record object shall be
+ *   returned instead of an array.
+ *
+ * Also, CDS, and hence CQN, supports minimalistic `SELECT` statements with a `from`
+ * as the only mandatory property, which is equivalent to SQL's `SELECT * from ...`.
+ */
+export class SELECT { SELECT: {
+  distinct?   : true
+  count?      : true
+  one?        : true
+  from        : source
+  columns?    : column[]
+  where?      : xo[]
+  having?     : xo[]
+  groupBy?    : expr[]
+  orderBy?    : order[]
+  limit?      : { rows: val, offset: val }
+}}
+
+type source = OneOf< ref &as | SELECT | {
+  join : 'inner' | 'left' | 'right'
+  args : [ source, source ]
+  on?  : expr
+}>
+
+type column = OneOf< '*' | expr &as &cast | ref &as & OneOf<(
+  { expand?: column[] } |
+  { inline?: column[] }
+)> &infix >
+
+type order = expr & {
+  sort  : 'asc' | 'desc'
+  nulls : 'first' | 'last'
+}
+
+
+interface changes { [elm:string]: OneOf< scalar | expr | changes | changes[] >}
+interface data { [elm:string]: OneOf< scalar | data | data[] >}
+interface as { as?: name }
+interface cast { cast?: {type:name} }
+
+interface infix {
+  orderBy?  : order[]
+  where?    : expr
+  limit?    : { rows: val, offset: val }
+}
+
+
+/**
+ * Expressions can be entity or element references, query parameters,
+ * literal values, lists of all the former, function calls, sub selects,
+ * or compound expressions.
+ */
+export type expr  = OneOf< ref | val | xpr | list | func | param | SELECT >
+export type ref   = { ref: OneOf< name | { id:name &infix } >[] }
+export type val   = { val: scalar }
+export type xpr   = { xpr: xo[] }
+export type list  = { list: expr[] }
+export type func  = { func: string, args: expr[] }
+export type param = { ref: [ '?' | number | string ], param: true }
+
+/**
+ * This is used in `{xpr}` objects as well as in `SELECT.where` clauses to
+ * represent compound expressions as flat `xo` sequences.
+ * Note that CQN by intent does not _understand_ expressions and therefore
+ * keywords and operators are just represented as plain strings.
+ * This allows us to translate to and from any other query languages,
+ * including support for native SQL features.
+ */
+type xo       = OneOf< expr | keyword | operator >
+type operator = '=' | '==' | '!=' | '<' | '<=' | '>' | '>='
+type keyword  = 'in' | 'like' | 'and' | 'or' | 'not'
+type scalar   = number | string | boolean | null
+type name     = string
+
+
+
+// ---------------------------------------------------------------------------
+//  maybe coming later...
+
+declare class CREATE { CREATE: {} }
+declare class DROP { DROP: {} }
+
+
+// ---------------------------------------------------------------------------
+//  internal helpers...
+
+type OneOf<U> = Partial<(U extends any ? (k:U) => void : never) extends (k: infer I) => void ? I : never>