@sap/cds 7.7.3 → 7.8.1

package/CHANGELOG.md

@@ -4,6 +4,36 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 7.8.1 - 2024-04-11
+
+### Fixed
+
+- In some cases, `<entity>.drafts` erroneously pointed to a CSN entity stub.
+- Feature vectors including falsy values like `{ ft1: true, ft2: true, ft3: false }`
+
+## Version 7.8.0 - 2024-03-25
+
+### Added
+
+- Health check endpoint `/health` in default server
+- Class `cds.service` now provides getters for `entities`, `types`, `events` and `operations`. These return iterable objects, which can be used in `for...of` loops.
+- Class `cds.entity` getters for `keys`, `associations`, `operations` also return `Iterable` objects now
+- Method `compile.to.serviceinfo()` now lists all Node.js service endpoints in cases where multiple protocols are configured. For Java, the list is still limited to the first endpoint. This will be fixed in a future release.
+- More warnings for deprecated features, functions and annotations.
+
+### Fixed
+
+- Reverted `cds.Association` being derived from `cds.struct`; it's now derived from `cds.type` again.
+- Entity definitions using joins were erroneously marked as `_unresolved`
+- Consistent error messages for query options validation with new parser
+- Validation for mandatory associations which target entities with defaulted keys
+- Transaction handling for aborted streaming requests
+- Create/Update over filtered managed compositions
+- Templates are cached at the model (instead of the service)
+- Deprecation warnings use `cds.log()` in production
+- Single quote in a string in `.where` for remote service
+- Escaped characters in double quoted search term when using `odata_new_parser`
+
 ## Version 7.7.3 - 2024-03-18
 
 ### Fixed
@@ -42,7 +72,7 @@
 - `cds.fiori.draft_lock_timeout` as successor of `cds.drafts.cancellationTimeout`.
   + Possible values are /^([0-9]+)(h|hrs|min)$/ or a number in milliseconds.
 - There is a new `sap.common.Timezones` entity with a basic time zone definition. There will be accompanying data in package `@sap/cds-common-content`.
-- Deprecation warnings for configuration options `cds.drafts.cancellationTimeout`, `cds.features.serve_on_root`, `cds.features.stream_compat`, `cds.fiori.lean_draft` and `cds.requires.middlewares`, as well as for the properties `req.user.locale` and `req.user.tenant`. The deprecation warnings can be turned off by setting `cds.features.deprecated` to `off`. 
+- Deprecation warnings for configuration options `cds.drafts.cancellationTimeout`, `cds.features.serve_on_root`, `cds.features.stream_compat`, `cds.fiori.lean_draft` and `cds.requires.middlewares`, as well as for the properties `req.user.locale` and `req.user.tenant`. The deprecation warnings can be turned off by setting `cds.features.deprecated` to `off`.
 
 ### Changed
 

package/lib/auth/ias-auth.js

@@ -5,6 +5,9 @@ const LOG = cds.log('auth')
 const _require = require('../../libx/_runtime/common/utils/require')
 const xssec = _require('@sap/xssec')
 
+// getter function extracted to show deprecation warning only once
+const _getTokenInfo = tokenInfo => tokenInfo
+
 module.exports = function ias_auth(config) {
   const { kind, credentials, known_claims } = config
 
@@ -56,9 +59,8 @@ module.exports = function ias_auth(config) {
       // -> the "always available" part is not true for ias (see REVISIT above)
       tokenInfo && Object.defineProperty(req, 'tokenInfo', {
         get() {
-          cds._logDeprecation('req.tokenInfo was added for compatibility purposes but will be removed in the next major version.')
-          return tokenInfo
-        }
+          return cds.utils.deprecated(_getTokenInfo, {kind: 'Property', old: 'req.tokenInfo'})(tokenInfo)
+         }
       })
 
       if (!securityContext) {

package/lib/auth/jwt-auth.js

@@ -5,6 +5,9 @@ const LOG = cds.log('auth')
 const _require = require('../../libx/_runtime/common/utils/require')
 const xssec = _require('@sap/xssec')
 
+// getter function extracted to show deprecation warning only once
+const _getTokenInfo = tokenInfo => tokenInfo
+
 module.exports = function jwt_auth(config) {
   const { kind, credentials } = config
 
@@ -56,8 +59,7 @@ module.exports = function jwt_auth(config) {
       // if no general problem, tokenInfo object is always available -> add to req via getter for compat reasons
       Object.defineProperty(req, 'tokenInfo', {
         get() {
-          cds._logDeprecation('req.tokenInfo was added for compatibility purposes but will be removed in the next major version.')
-          return tokenInfo
+          return cds.utils.deprecated(_getTokenInfo, {kind: 'Property', old: 'req.tokenInfo'})(tokenInfo)
         }
       })
 

package/lib/compile/cdsc.js

@@ -100,16 +100,6 @@ const _options = {for: Object.assign (_options4, {
 })}
 
 
-const { inspect } = require('util')
-compile.CompilationError.prototype [inspect.custom] = function() {
-  // return this.stack
-  return 'Errors by cds.compile ...'+ this.messages.map (e => {
-    let {file,line,col} = e.$location
-    return `\nin ${file}:${line}:${col} — ${e.severity}: ${e.message}`
-  }).join('') + this.stack.slice(this.message.length+7)
-}
-
-
 /**
  * Return a derivate of cdsc, with the most prominent
  * @type { import('@sap/cds-compiler') }

package/lib/compile/for/java.js

@@ -2,15 +2,19 @@
 
 const cds = require ('../../index')
 
-// TODO: compiler functions to clarify - publish as individual API functions or
-// have a compiler API function for.java?
 function _4java (csn,o) {
   const compile = require ('../cdsc');
-  const { addTenantFields } = require ('@sap/cds-compiler/lib/transform/addTenantFields');
+  o = compile._options.for.odata(o); // get compiler options, see compile.for.odata
+  return (compile.for.java ?? _4java_tmp) (csn,o);
+}
+
+function _4java_tmp (csn,o) { // as long as compile.for.java is not definitely there
   const _4draft = require ('@sap/cds-compiler/lib/transform/draft/odata');
   const dsn = JSON.parse (JSON.stringify (csn)) // REVISIT: workaround for bad test setup
-  o = compile._options.for.odata(o); // get compiler options, see compile.for.odata
-  if (o.tenantDiscriminator) addTenantFields (dsn, o);
+  if (o.tenantDiscriminator) {
+    const { addTenantFields } = require ('@sap/cds-compiler/lib/transform/addTenantFields');
+    addTenantFields (dsn, o);
+  }
   return _4draft (dsn, o);
 }
 

package/lib/compile/for/lean_drafts.js

@@ -118,7 +118,7 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
         if (e._target['@odata.draft.enabled'] === false) continue // happens for texts if @fiori.draft.enabled is not set
         _redirect(newEl, addDraftEntity(e._target, model))
       }
-      newEl.parent = draft
+      Object.defineProperty (newEl,'parent',{value:draft,enumerable:false, configurable: true, writable: true})
 
       for (const key in newEl) {
         if (

package/lib/compile/to/edm.js

@@ -7,13 +7,14 @@ if (cds.env.features.precompile_edms !== false) {
   cdsc.to.edm = Object.assign((csn, o) => {
     if (o.to === 'openapi') return to_edm(csn, o)
     if (!_precompiled.has(csn)) {
-      if (!o.serviceNames) o = { ...o, serviceNames: cds.linked(csn).services.filter(srv => srv._serves_odata).map(d => d.name) }
+      if (!o.serviceNames) o = { ...o, serviceNames: cds.linked(csn).services.filter(d => 'odata' in d.protocols).map(d => d.name) }
       _precompiled.set(csn, cdsc.to.edm.all(csn, o))
     }
     return _precompiled.get(csn)[o.service]
   }, { all: cdsc.to.edm.all })
 }
 
+
 function cds_compile_to_edm (csn,_o) {
   const o = cdsc._options.for.edm(_o) //> used twice below...
   csn = _4odata(csn,o)

package/lib/compile/to/sql.js

@@ -7,7 +7,6 @@ const TRACE = cds.debug('trace')
 function cds_compile_to_sql (csn,_o) {
   TRACE?.time('cdsc.compile 2sql'.padEnd(22))
   csn = cds.minify(csn)
-  csn = _extended(csn)
   const o = cdsc._options.for.sql(_o) //> used twice below...
   const all = cdsc.to.sql(csn,o) .map (each => each.replace(/^-- .+\n/,''))  //> strip comments
   const sql = unfold_ddl(all, csn, o)
@@ -56,23 +55,3 @@ module.exports = Object.assign (cds_compile_to_sql, {
   delta: cds_compile_to_deltaSql,
   sqlite: { keywords },
 })
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-// UI Flex - read extensions__ to views, when ext fields are read
-// REVISIT: We planned to remove the uiflex feature -> should do so
-const _extended = (csn) => {
-  const defs = cds.linked(csn).definitions
-  for (let each in defs) {
-    const d = defs[each], columns = d.query?.SELECT?.columns || d.projection?.columns
-    if (columns && _is_extensible(d)) {
-      if (!columns.some(({ref}) => ref?.[0] === _extensions)) columns.push({ref:[_extensions]})
-    }
-  }
-  return csn
-}
-const _is_extensible = d => _extensions in d.elements || d.__proto__.elements && _is_extensible (d.__proto__)
-const _extensions = 'extensions__'
-/////////////////////////////////////////////////////////////////////////////

package/lib/compile/to/srvinfo.js

@@ -29,21 +29,30 @@ module.exports = (model, options={}) => {
   return result
 
   function _makeJava(service) {
+    // use first endpoint, preferably odata
+    // TODO handle multiple protocols for java, see https://cap.cloud.sap/docs/java/application-services#serve-configuration
+    const kind = Object.keys(service.protocols).find(k => k.startsWith('odata')) || Object.keys(service.protocols)[0]
+    const endpoints = [{ kind, path: _url4(_javaPath(service)) }]
     return {
       name: service.name,
-      urlPath: _url4 (_javaPath(service)),
+      urlPath: endpoints[0].path, // legacy
       destination: 'srv-api', // the name to register in xs-app.json
+      endpoints,
       runtime: 'Java',
       location: service.$location
     }
   }
   function _makeNode(service) {
+    // make a fake runtime object for the service, adding a `definition` property
+    if (!service.definition)  Object.defineProperty(service, 'definition', { value: service, enumerable: false })
+    const endpoints = cds.service.protocols.endpoints4(service).map(e => Object.assign({}, e, { path: _url4(e.path) }))
     return {
       name: service.name,
-      urlPath: _url4 (cds.service.protocols.path4(service)),
+      urlPath: endpoints[0].path, // legacy
       destination: 'srv-api', // the name to register in xs-app.json
+      endpoints,
       runtime: 'Node.js',
-      location: service.$location
+      location: service.$location,
     }
   }
 
@@ -53,7 +62,7 @@ module.exports = (model, options={}) => {
       p = p.replace(/\\/g, '/') // handle Windows
            .replace(/^\/+/, '') // strip leading
            .replace(/\/+$/, '') // strip trailing
-      p += '/' // end with /
+      if (!p.endsWith('/'))  p += '/' // end with /
       return p
     }
   }

package/lib/dbs/cds-deploy.js

@@ -149,12 +149,11 @@ deploy.schema = async function (db, csn = db.model, o) {
 deploy.data = async function (db, csn = db.model, o, srces, log=()=>{}) {
 
   const t = cds.context?.tenant; if (t && t === cds.requires.multitenancy?.t0) return
-  const crypto = require('crypto')
 
   return db.run (async tx => {
     TRACE?.time('cds.deploy data'.padEnd(22))
 
-    const m = tx.model = cds.compile.for.nodejs(csn) // NOTE: this used to create a redundant 4nodejs model for tha same csn
+    const m = tx.model = cds.compile.for.nodejs(csn) // NOTE: this used to create a redundant 4nodejs model for the same csn
     const data = await deploy.prepare (m,srces)
     const query = _queries4 (db,m)
     const INSERT_from = INSERT_from4 (db,m,o)
@@ -207,12 +206,12 @@ deploy.data = async function (db, csn = db.model, o, srces, log=()=>{}) {
     return (file) => ({
       '.json': { into (entity, json) {
         let records = JSON.parse(json); if (!records.length) return
-        _add_ID_texts4 (entity, records)
+        _add_ID_texts4 (entity, m, records)
         return INSERT_into(entity).entries(records)
       }},
       '.csv': { into (entity, csv) {
         let [cols, ...rows] = cds.parse.csv(csv); if (!rows.length) return
-        _add_ID_texts4 (entity, rows, cols)
+        _add_ID_texts4 (entity, m, rows, cols)
         return INSERT_into(entity).columns(cols).rows(rows)
       }},
     }) [path.extname(file)]
@@ -223,12 +222,13 @@ deploy.data = async function (db, csn = db.model, o, srces, log=()=>{}) {
    * IMPORTANT: we use UUIDs generated from hashes of all original key values (ID, locale, ...)
    * to ensure same ID_texts values for same keys across different deployments.
    */
-  function _add_ID_texts4 (entity, records, cols) {
+  function _add_ID_texts4 (entity, m, records, cols) {
     if (entity.name)  entity = entity.name  //> entity can be an entity name or a definition
-    if (!csn.definitions[entity]?.keys?.ID_texts) return // it's not a .texts entity with ID_texts key
+    if (!m.definitions[entity]?.keys?.ID_texts) return // it's not a .texts entity with ID_texts key
     if ((cols || Object.keys(records[0])).includes('ID_texts')) return // already there
     else DEBUG?.(`adding ID_texts for ${entity}`)
-    const keys = Object.keys (csn.definitions[entity.slice(0,-6)].keys) .concat ('locale')
+    const keys = Object.keys (m.definitions[entity.slice(0,-6)].keys) .concat ('locale')
+    const crypto = require('crypto')
     if (cols) {
       cols.push ('ID_texts')
       const indexes = keys.map (k => cols.indexOf(k))

package/lib/env/cds-requires.js

@@ -217,6 +217,12 @@ const _messaging = {
     impl: `${_runtime}/messaging/message-queuing.js`,
     outbox: true
   },
+  'kafka': {
+    impl: `${_runtime}/messaging/kafka.js`,
+    topic: 'cds.default',
+    outbox: true,
+    local: false
+  },
   "composite-messaging": {
     impl: `${_runtime}/messaging/composite.js`
   },

package/lib/index.js

@@ -103,9 +103,10 @@ const cds = module.exports = global.cds = new class cds extends EventEmitter {
   exit(code){ return cds.shutdown ? cds.shutdown() : process.exit(code) }
 
   // Querying and Databases
+  get txs()  { return super.txs = new this.Service('cds.tx') }
   get ql()   { return super.ql = require('./ql/cds-ql') }
-  tx         (..._) { return (this.db || this.Service.prototype) .tx (..._) }
-  run        (..._) { return (this.db || this.error._no_primary_db).run(..._) }
+  tx         (..._) { return (this.db || this.txs).tx(..._) }
+  run        (..._) { return (this.db || typeof _[0] === 'function' && this.txs || this.error._no_primary_db).run(..._) }
   foreach    (..._) { return (this.db || this.error._no_primary_db).foreach(..._) }
   stream     (..._) { return (this.db || this.error._no_primary_db).stream(..._) }
   read       (..._) { return (this.db || this.error._no_primary_db).read(..._) }
@@ -144,6 +145,6 @@ if (process.env.CDS_JEST_MEM_FIX && typeof jest !== 'undefined') require('./util
 // Setting it to module.exports lead to issues with vitest while setting it to cds apparently works fine.
 if (process.env.CDS_ESM_INTEROP_DEFAULT) {
   Object.defineProperties(module.exports, { default: {value:module.exports}, __esModule: {value:true} })
-} else { 
+} else {
   Object.defineProperties(module.exports, { default: {value:cds}, __esModule: {value:true} })
 }

package/lib/linked/classes.js

@@ -1,13 +1,13 @@
 const { extend } = require('../lazy')
+const _proxy = Symbol('_proxy')
 
-class any {
+class any { is (kind) { return this.kind === kind || kind === 'any' }
 
   constructor(...aspects) { Object.assign (this,...aspects) }
   set name(n) { this.set('name', n, false) }
   set kind(k) { this.set('kind', k, true) }
   get kind() { return this.set('kind', this.parent ? 'element' : 'type') }
-  is (kind) { return this.kind === kind || kind === 'any' }
-  valueOf() { return this.name }
+  valueOf() { return this.name || this }
 
   own (property, ifAbsent) {
     const pd = Reflect.getOwnPropertyDescriptor (this, property)
@@ -20,111 +20,174 @@ class any {
     return value
   }
 
-  dataIn (d, prefix='') {
-    return d[prefix + this.name]
+  toJSON() {
+    const o={}; for (let p in this) o[p] = this[p]
+    return o
   }
-}
-
-class type extends any {}
-class action extends any {}
-class context extends any {}
 
-class service extends context {
-  /** @type <T> (p,v:T) => T */ static _lazy (p,v) { Reflect.defineProperty (this,p,{value:v}); return v }
-  static get protocols() { return this._lazy ('protocols', require('../srv/protocols')) }
-  static get bindings() { return this._lazy ('bindings', require('../srv/bindings')) }
-  static get factory() { return this._lazy ('factory', require('../srv/factory')) }
-  static endpoints4(..._) { return this.protocols.endpoints4(..._) }
-  static path4(..._) { return this.protocols.path4(..._) }
-  get _serves_odata() { return super._serves_odata = service.protocols._serves_odata(this) }
+  dataIn (d, prefix='') { return d[prefix + this.name] }
 }
 
-class array extends type { is(kind) { return kind === 'array' || super.is(kind) }}
-class aspect extends type { is(kind) { return kind === 'aspect' || super.is(kind) }}
-class event extends aspect{}
+class aspect extends any { is(kind) { return kind === 'aspect' || super.is(kind) }}
+class type extends any { is(kind) { return kind === 'type' || super.is(kind) }
+  toJSON() {
+    return this.own('type') ? {...this} : super.toJSON()
+  }
+}
 
-class struct extends aspect {
-  is(kind) { return kind === 'struct' || super.is(kind) }
+  class scalar extends type {}
+
+    class boolean extends scalar {}
+      class Boolean extends boolean {}
+
+    class string extends scalar {}
+      class UUID extends string {}
+      class String extends string {}
+        class LargeString extends String {}
+      class Binary extends string {}
+        class LargeBinary extends Binary {}
+        class Vector extends Binary {}
+
+    class number extends scalar {}
+      class Integer extends number {}
+        class UInt8 extends Integer {}
+        class Int16 extends Integer {}
+        class Int32 extends Integer {}
+        class Int64 extends Integer {}
+      class Float extends number {}
+        class Double extends Float {}
+        class Decimal extends Float {}
+
+    class date extends scalar {}
+      class Date extends date {}
+      class Time extends date {}
+      class DateTime extends date {}
+        class Timestamp extends DateTime {}
+
+  class array extends type { is(kind) { return kind === 'array' || super.is(kind) }}
+  class struct extends type { is(kind) { return kind === 'struct' || super.is(kind) }
+
+    /**
+     * Gets the foreign key data for a given managed association from inbound data
+     * in structured form.
+     *
+     * @example
+     * let { Books } = srv.entities
+     * let { author } = Books.elements
+     * let book = { // inbound data, e.g. from req.data
+     *   title: 'Foo',
+     *   author_ID: 111
+     * }
+     * let value = author.dataIn(book)
+     * //> { ID: 111 }
+     *
+     * Actually this works for all struct-like elements, i.e., which's definitions
+     * have .elements or .foreignKeys. Could be added to cds.struct/cds.Association.
+     */
+    dataIn (d, prefix='', _skip_root) {
+      const key = prefix + this.name; if (!_skip_root && key in d) return d[key]
+      const elements = this.elements || this.foreignKeys
+      const nested={}, key_ = _skip_root ? '' : key+'_'
+      let any; for (let e in elements) {
+        const v = elements[e] .dataIn (d,key_)
+        if (v !== undefined) nested[any=e] = v
+      }
+      if (any) return !prefix && d._hull ? d._hull[key] = nested : nested
+    }
 
-  /**
-   * Gets the foreign key data for a given managed association from inbound data
-   * in structured form.
-   *
-   * @example
-   * let { Books } = srv.entities
-   * let { author } = Books.elements
-   * let book = { // inbound data, e.g. from req.data
-   *   title: 'Foo',
-   *   author_ID: 111
-   * }
-   * let value = author.dataIn(book)
-   * //> { ID: 111 }
-   *
-   * Actually this works for all struct-like elements, i.e., which's definitions
-   * have .elements or .foreignKeys. Could be added to cds.struct/cds.Association.
-   */
-  dataIn (d, prefix='', _skip_root) {
-    const key = prefix + this.name; if (!_skip_root && key in d) return d[key]
-    const elements = this.elements || this.foreignKeys // REVISIT: .foreignKeys should be .elements
-    const nested={}, key_ = _skip_root ? '' : key+'_'
-    let any; for (let e in elements) {
-      const v = elements[e] .dataIn (d,key_)
-      if (v !== undefined) nested[any=e] = v
+    /**
+     * Returns a Proxy for provided data which adds getters to return values
+     * for struct elements (including Associations) in structured form.
+     *
+     * @example
+     * let { Books } = m.entities
+     * let data = Books.data ({
+     *   author: {ID:111},
+     *   genre_ID: 22
+     * })
+     * console.log ('author:', data.author) //> { ID: 111 }
+     * console.log ('genre:', data.genre)  //> { ID: 22 }
+     */
+    data (d) {
+      if (_proxy in d) return d[_proxy] //> use cached proxy, if exists
+
+      // hull to cache calculated values without polluting original input
+      const _hull = {__proto__:d}
+
+      // allow external code to access _hull
+      Object.defineProperty (_hull, '_hull', {value:_hull})
+
+      // proxy calls def.dataIn() for defined elements, fallback hull[p]
+      const {elements} = this, proxy = new Proxy (d, {
+        get: (_,p) => elements[p]?.dataIn?.(_hull) || _hull[p],
+      })
+
+      // cache proxy with original data
+      Object.defineProperty (d, _proxy, {value:proxy})
+
+      return proxy
     }
-    if (any) return !prefix && d._hull ? d._hull[key] = nested : nested
   }
 
-  /**
-   * Returns a Proxy for provided data which adds getters to return values
-   * for struct elements (including Associations) in structured form.
-   *
-   * @example
-   * let { Books } = m.entities
-   * let data = Books.data ({
-   *   author: {ID:111},
-   *   genre_ID: 22
-   * })
-   * console.log ('author:', data.author) //> { ID: 111 }
-   * console.log ('genre:', data.genre)  //> { ID: 22 }
-   */
-   data (d) {
-    if (_proxy in d) return d[_proxy] //> use cached proxy, if exists
-
-    // hull to cache calculated values without polluting original input
-    const _hull = {__proto__:d}
-
-    // allow external code to access _hull
-    Object.defineProperty (_hull, '_hull', {value:_hull})
+class context extends any {}
+class service extends context {
 
-    // proxy calls def.dataIn() for defined elements, fallback hull[p]
-    const {elements} = this, proxy = new Proxy (d, {
-      get: (_,p) => elements[p]?.dataIn(_hull) || _hull[p],
-    })
+  get entities()   { return this.set('entities', this._collect (d => d.kind === 'entity')) }
+  get types()      { return this.set('types',    this._collect (d => d.kind === 'type' || !d.kind)) }
+  get events()     { return this.set('events',   this._collect (d => d.kind === 'event')) }
+  get actions()    { return this.set('actions',  this._collect (d => d.kind === 'action' || d.kind === 'function')) }
+  get operations() { return this.set('actions',  this._collect (d => d.kind === 'action' || d.kind === 'function')) }
+
+  /** @private */ _collect (filter) {
+    const defs = this.model?.definitions, prefix = this.name+'.', dict = new LinkedDefinitions
+    for (let each in defs) {
+      let d = defs[each]
+      if (d._service === this && filter(d)) dict[each.slice(prefix.length)] = d
+    }
+    return dict
+  }
 
-    // cache proxy with original data
-    Object.defineProperty (d, _proxy, {value:proxy})
+  get protocols()  { return this.set('protocols',  service.protocols.for(this)) }
+  static get protocols() { return this._lazy ('protocols', require('../srv/protocols')) }
+  static get bindings() { return this._lazy ('bindings', require('../srv/bindings')) }
+  static get factory() { return this._lazy ('factory', require('../srv/factory')) }
+  static endpoints4(..._) { return this.protocols.endpoints4(..._) }
+  static path4(..._) { return this.protocols.path4(..._) }
 
-    return proxy
+  /** @private @type <T> (p,v:T) => T */ static _lazy (p,v) {
+    Reflect.defineProperty (this,p,{value:v})
+    return v
   }
+}
+class action extends any {}
+class event extends aspect {}
+
 
+class LinkedDefinitions {
+  *[Symbol.iterator](){ for (let e in this) yield this[e] }
+  forEach(f){ let i=0; for (let k in this) f(this[k],i++,this) }
+  filter(f){ let i=0, r=[]; for (let k in this) f(this[k],i++,this) && r.push(k); return r }
+  map(f){ let i=0, r=[]; for (let k in this) r.push(f(this[k],i++,this)); return r }
+  some(f){ for (let k in this) if (f(this[k])) return true }
+  find(f){ for (let k in this) if (f(this[k])) return k }
 }
-const _proxy = Symbol('_proxy')
 
 
-/**
- * Export is a dictionary of all builtin classes
- */
 module.exports = {
 
-  any,
-  type,
-  array,
-  aspect,
-  struct,
+  LinkedDefinitions,
+
+  any, type, aspect, struct, array,
+  scalar, boolean, string, number, date,
+  service, event, action,
   context,
-  service,
-  action,
-  event,
+
+  UUID, Boolean, String,
+  Integer, UInt8, Int16, Int32, Int64,
+
+  Float, Double, Decimal,
+  Date, Time, DateTime, Timestamp,
+  Binary, Vector, LargeBinary, LargeString,
 
   /**
    * Allows to mixin functions or properties to several equally named builtin classes