@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/compiler/assert-consistency.js

@@ -98,6 +98,8 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$newfeatures',
         '$messageFunctions',
+        '$functions',
+        '$volatileFunctions',
       ],
     },
     ':parser': {                // top-level from parser
@@ -247,7 +249,7 @@ function assertConsistency( model, stage ) {
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
-          '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
+          '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
       },
       none: { optional: () => true }, // parse error
@@ -479,6 +481,7 @@ function assertConsistency( model, stage ) {
     },
     items: {
       kind: true,
+      also: [ 0 ],              // 0 for cyclic expansions
       requires: [ 'location' ],
       optional: [
         'enum',
@@ -539,7 +542,7 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit',
+        'limit', '_status',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -588,6 +591,8 @@ function assertConsistency( model, stage ) {
     $sources: { parser: true, test: isArray( isString ) },
     $expected: { parser: true, test: isString },
     $messageFunctions: { test: TODO },
+    $functions: { test: TODO },
+    $volatileFunctions: { test: TODO },
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );
@@ -659,6 +664,8 @@ function assertConsistency( model, stage ) {
   }
 
   function standard( node, parent, prop, spec, name ) {
+    if (spec.also && spec.also.includes( node ))
+      return;
     isObject( node, parent, prop, spec, name );
 
     const names = Object.getOwnPropertyNames( node );

package/lib/compiler/base.js

@@ -0,0 +1,65 @@
+// Base Definitions for the Core Compiler
+
+
+'use strict';
+
+const dictKinds = {
+  definitions: 'absolute',
+  elements: 'element',
+  enum: 'enum',
+  foreignKeys: 'key',
+  actions: 'action',
+  params: 'param',
+};
+
+const kindProperties = {
+  // TODO: also foreignKeys ?
+  namespace: { artifacts: true }, // on-the-fly context
+  context: { artifacts: true, normalized: 'namespace' },
+  service: { artifacts: true, normalized: 'namespace' },
+  entity: { elements: true, actions: true, params: () => false },
+  select: { normalized: 'select', elements: true },
+  $join: { normalized: 'select' },
+  $tableAlias: { normalized: 'alias' }, // table alias in select
+  $self: { normalized: 'alias' }, // table alias in select
+  $navElement: { normalized: 'element' },
+  $inline: { normalized: 'element' }, // column with inline property
+  event: { elements: true },
+  type: { elements: propExists, enum: propExists },
+  aspect: { elements: propExists },
+  annotation: { elements: propExists, enum: propExists },
+  enum: { normalized: 'element' },
+  element: { elements: propExists, enum: propExists, dict: 'elements' },
+  mixin: { normalized: 'alias' },
+  action: {
+    params: () => false, elements: () => false, enum: () => false, dict: 'actions',
+  }, // no extend params, only annotate
+  function: {
+    params: () => false, elements: () => false, enum: () => false, normalized: 'action',
+  }, // no extend params, only annotate
+  key: { normalized: 'element' },
+  param: { elements: () => false, enum: () => false, dict: 'params' },
+  source: { artifacts: true },  // TODO -> $source
+  using: {},
+  extend: {
+    isExtension: true,
+    noDep: 'special',
+    elements: true, /* only for parse-cdl */
+    actions: true,  /* only for parse-cdl */
+  },
+  annotate: {
+    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
+  },
+  builtin: {},                  // = CURRENT_DATE, TODO: improve
+  $parameters: {},              // $parameters in query entities
+};
+
+function propExists( prop, parent ) {
+  const obj = parent.returns || parent;
+  return (obj.items || obj.targetAspect || obj)[prop];
+}
+
+module.exports = {
+  dictKinds,
+  kindProperties,
+};

package/lib/compiler/builtins.js

@@ -2,9 +2,8 @@
 
 'use strict';
 
-const { forEachInDict } = require('../base/dictionaries');
 const { builtinLocation } = require('../base/location');
-const { setProp } = require('../base/model');
+const { setProp } = require('./utils');
 
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
@@ -82,18 +81,19 @@ const specialFunctions = {
  */
 const magicVariables = {
   $user: {
+    // id and locale are always available
     elements: { id: {}, locale: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
-  },                  // CDS-specific, not part of SQL
-  $at: {
+  },
+  $at: { // CDS-specific, not part of SQL
     elements: {
       from: {}, to: {},
     },
   },
-  $now: {},                   // Dito
+  $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
@@ -167,6 +167,31 @@ function isRelationTypeName(typeName) {
   return typeCategories.relation.includes(typeName);
 }
 
+/**
+ * Checks whether the given absolute path is inside a reserved namespace.
+ *
+ * @param {string} absolute
+ * @returns {boolean}
+ */
+function isInReservedNamespace(absolute) {
+  return absolute.startsWith( 'cds.') &&
+    !absolute.match(/^cds\.foundation(\.|$)/) &&
+    !absolute.match(/^cds\.outbox(\.|$)/); // Requested by Node runtime
+}
+
+/**
+ * Tell if a type is (directly) a builtin type
+ * Note that in CSN builtins are not in the definition of the model, so we can only
+ * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
+ * are directly in 'cds', but not for example in 'cds.foundation'.
+ *
+ * @param {string} type
+ * @returns {boolean}
+ */
+function isBuiltinType(type) {
+  return typeof type === 'string' && isInReservedNamespace(type);
+}
+
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -174,6 +199,7 @@ function isRelationTypeName(typeName) {
  * @param {XSN.Model} model XSN model without CDS builtins
  */
 function initBuiltins( model ) {
+  const { options } = model;
   setMagicVariables( magicVariables );
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
@@ -241,27 +267,45 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, element: name } };
+      const art = { kind: 'builtin', name: { element: name, id: name } };
       artifacts[name] = art;
-      if (magic.elements)
-        art.elements = forEachInDict( magic.elements, (e, n) => magicElement( e, n, art ));
+
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+
+      createMagicElements( art, magic.elements );
+      if (options.variableReplacements)
+        createMagicElements( art, options.variableReplacements[name] );
       // setProp( art, '_effectiveType', art );
     }
     model.$magicVariables = { kind: '$magicVariables', artifacts };
   }
 
-  function magicElement( spec, name, parent ) {
-    const magic = {
-      kind: 'builtin',
-      name: { id: name, element: `${ parent.name.element }.${ name }` },
-    };
-    setProp( magic, '_parent', parent );
-    // setProp( magic, '_effectiveType', magic );
-    return magic;
+  function createMagicElements( art, elements ) {
+    if (!elements)
+      return;
+
+    const names = Object.keys(elements);
+    if (names.length > 0 && !art.elements)
+      art.elements = Object.create(null);
+
+    for (const n of names) {
+      const magic = {
+        kind: 'builtin',
+        name: { id: n, element: `${ art.name.element }.${ n }` },
+      };
+      // Propagate this property so that it is available for sub-elements.
+      if (art.$uncheckedElements)
+        magic.$uncheckedElements = art.$uncheckedElements;
+      setProp( magic, '_parent', art );
+      // setProp( magic, '_effectiveType', magic );
+      if (elements[n] && typeof elements[n] === 'object')
+        createMagicElements(magic, elements[n]);
+
+      art.elements[n] = magic;
+    }
   }
 }
 
@@ -269,6 +313,8 @@ module.exports = {
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,
+  isInReservedNamespace,
+  isBuiltinType,
   isIntegerTypeName,
   isDecimalTypeName,
   isNumericTypeName,

package/lib/compiler/checks.js

@@ -632,8 +632,9 @@ function check( model ) {       // = XSN
    * @returns {void}
    */
   function checkTokenStreamExpression(xpr, allowAssocTail) {
+    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args || {});
     // Check for illegal argument usage within the expression
-    for (const arg of xpr.args || []) {
+    for (const arg of args) {
       if (isVirtualElement(arg))
         error(null, arg.location, 'Virtual elements can\'t be used in an expression');
 

package/lib/compiler/definer.js

@@ -88,7 +88,7 @@
 // Sub Phase 2 (initXYZ)
 //  - set _parent, _main (later: _service?) links, and _block links of members
 //  - add _subArtifacts dictionary and "namespace artifacts" for name resolution
-//  - duplicate checks (TODO - currently via preProcessArtifact in definer)
+//  - duplicate checks
 //  - structure checks ?
 //  - annotation assignments
 //  - POST: resolvePath() can be called for artifact references (if complete model)
@@ -101,9 +101,11 @@
 //    to avoid consequential or repeated errors.
 //  - But: The same artifact is added to multiple dictionaries.
 //  - Solution part 1: $duplicates as property of the artifact or member
-//    for 'definitions', '_artifacts' and member dictionaries.
-//  - Solution part 2: array value in dictionary for duplicates in CDL 'artifacts'
-//    dictionary, also used for `_combined` in query search dictionary.
+//    for `definitions`, `_artifacts`, member dictionaries, `vocabulary`
+//    dictionary of the whole model, `$tableAliases` dictionary of queries.
+//  - Solution part 2: array value in dictionary for duplicates in CDL `artifacts`
+//    dictionary, `_combined` dictionary for query search, `$tableAliases`
+//    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
 
 'use strict';
 
@@ -111,7 +113,7 @@ const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled, isBetaEnabled,
   setProp, forEachGeneric, forEachInOrder,
-  forEachMember, forEachDefinition,
+  forEachDefinition,
   forEachMemberRecursivelyWithQuery,
 } = require('../base/model');
 const {
@@ -120,20 +122,21 @@ const {
 const {
   dictLocation,
 } = require('../base/location');
+const { kindProperties, dictKinds } = require('./base');
 const {
-  annotationVal, annotationIsFalse, annotateWith,
-} = require('./utils');
-const {
-  dictKinds,
-  kindProperties,
-  fns,
+  annotationVal,
+  annotationIsFalse,
+  annotateWith,
   linkToOrigin,
   setMemberParent,
   storeExtension,
   dependsOnSilent,
-} = require('./shared');
+  pathName,
+  augmentPath,
+  splitIntoPath,
+} = require('./utils');
 const { compareLayer, layer } = require('./moduleLayers');
-const { initBuiltins } = require('./builtins');
+const { initBuiltins, isInReservedNamespace } = require('./builtins');
 const setLink = setProp;
 
 /**
@@ -148,7 +151,7 @@ const setLink = setProp;
  *
  * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
  */
-function getDefinerFunctions( model ) {
+function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
@@ -160,24 +163,29 @@ function getDefinerFunctions( model ) {
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model );
-  const extensionsDict = Object.create(null);
-  let addTextsLanguageAssoc = false;
-
-  return {
-    define,
+  } = model.$functions;
+  Object.assign( model.$functions, {
     initArtifact,
     lateExtensions,
     projectionAncestor,
     hasTruthyProp,
+  } );
+  // During the definer, we can only resolve artifact references, i.e,
+  // after a `.`, we only search in the `_subArtifacts` dictionary:
+  model.$volatileFunctions.environment = function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
   };
 
+  const extensionsDict = Object.create(null);
+  let addTextsLanguageAssoc = false;
+  return doDefine();
+
   /**
    * Main function of the definer.
    *
    * @returns {XSN.Model}
    */
-  function define() {
+  function doDefine() {
     if (options.deprecated &&
         messages.every( m => m.messageId !== 'api-deprecated-option' )) {
       warning( 'api-deprecated-option', {},
@@ -206,8 +214,6 @@ function getDefinerFunctions( model ) {
 
     if (options.parseCdl) {
       initExtensionsWithoutApplying();
-      // Check for redefinitions
-      Object.keys( model.definitions ).forEach( preProcessArtifact );
       // If no extensions shall be applied then we can skip further
       // artifact processing and return the model with an `extensions` property.
       return model;
@@ -215,7 +221,6 @@ function getDefinerFunctions( model ) {
 
     applyExtensions();
 
-    Object.keys( model.definitions ).forEach( preProcessArtifact );
     const commonLanguagesEntity // TODO: remove beta after a grace period
         = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
           model.definitions['sap.common.Languages'];
@@ -238,13 +243,13 @@ function getDefinerFunctions( model ) {
    * @param {XSN.AST} src
    */
   function addSource( src ) {
-    // handle sub model from CSN parser
+    // handle sub model from parser
     if (!src.kind)
       src.kind = 'source';
 
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
-    if (prefix.startsWith( 'cds.') && !prefix.match(/^cds\.foundation(\.|$)/)) {
+    if (isInReservedNamespace(prefix)) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -280,8 +285,7 @@ function getDefinerFunctions( model ) {
   function addDefinition( art, block ) {
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' ||
-        absolute.startsWith( 'cds.') && !absolute.match(/^cds\.foundation(\.|$)/)) {
+    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -305,7 +309,7 @@ function getDefinerFunctions( model ) {
     }
     else {
       setLink( art, '_block', block );
-      // dictAdd might set $duplicates to true if def in other source
+      // dictAdd might set $duplicates to true
       dictAdd( model.definitions, absolute, art );
       return true;
     }
@@ -444,6 +448,23 @@ function getDefinerFunctions( model ) {
 
   // Phase 2 ("init") --------------------------------------------------------
 
+  function checkRedefinition( art ) {
+    if (!art.$duplicates)
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.absolute,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
   function initNamespaceAndUsing( src ) {
     if (src.namespace) {
       const decl = src.namespace;
@@ -488,6 +509,7 @@ function getDefinerFunctions( model ) {
     if (!reInit)
       initParentLink( art, model.definitions );
     const block = art._block;
+    checkRedefinition( art );
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
@@ -513,6 +535,7 @@ function getDefinerFunctions( model ) {
 
   function initVocabulary( art ) {
     initParentLink( art, model.vocabularies );
+    checkRedefinition( art );
     const block = art._block;
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
@@ -554,20 +577,6 @@ function getDefinerFunctions( model ) {
 
   // From here til EOF, reexamine code ---------------------------------------
 
-  // currently called from preProcessArtifact(), do be called in "init"
-  function checkRedefinitions( obj, name, prop ) {
-    forEachMember( obj, checkRedefinitions, obj.targetAspect );
-    if (!obj.$duplicates)
-      return;
-    if (obj.name.location.file === '<built-in>') {
-      // builtin types like namespace 'cds' or namespace 'localized' shouldn't be printed.
-      // The error shall only be printed for the user-defined conflicting artifact.
-      return;
-    }
-    error( 'duplicate-definition', [ obj.name.location, obj ],
-           { name, '#': (obj.kind === 'namespace') ? 'namespace' : dictKinds[prop] } );
-  }
-
   function initDollarSelf( art ) {
     const selfname = '$self';
     // TODO: use setMemberParent() ?
@@ -774,12 +783,13 @@ function getDefinerFunctions( model ) {
       setMemberParent( table, table.name.id, query );
       setProp( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
-        error( 'duplicate-definition', [ loc, table ], { name, '#': '$tableAlias' } );
+        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
       } );
       // also add to JOIN nodes for name restrictions:
       for (const p of joinParents) {
-        // console.log('ADD:', query.name.id, parents.length, p)
-        dictAdd( p.$tableAliases, table.name.id, table );
+        // for JOIN alias restriction, we cannot use $duplicates, as it is
+        // already used for duplicate aliases of queries:
+        dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
         warning( 'syntax-dollar-ident', [ table.name.location, table ], {
@@ -793,8 +803,8 @@ function getDefinerFunctions( model ) {
 
   // art is:
   // - entity for top-level queries (including UNION args)
-  // - $tableAlias for sub query in FROM
-  // - $query for real sub query (in columns, WHERE, ...)
+  // - $tableAlias for sub query in FROM - TODO: what about UNION there?
+  // - $query for real sub query (in columns, WHERE, ...), again: what about UNION there?
   function initQueryExpression( query, art ) {
     if (!query)                 // parse error
       return query;
@@ -846,7 +856,7 @@ function getDefinerFunctions( model ) {
       query.kind = 'select';
       query.name = { location: query.location };
       setMemberParent( query, main.$queries.length + 1, main );
-      // console.log(JSON.stringify(query.name))
+      // console.log(art.kind,art.name,query.name,query._$next.name)
       // if (query.name.query === 1 && query.name.absolute === 'S') throw Error();
       main.$queries.push( query );
       setProp( query, '_parent', art ); // _parent should point to alias/main/query
@@ -866,7 +876,7 @@ function getDefinerFunctions( model ) {
           // assignments on the mixin... (also for future mixin definitions
           // with generated values)
           dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
-            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': '$tableAlias' } );
+            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
             warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
@@ -993,6 +1003,7 @@ function getDefinerFunctions( model ) {
       setProp( elem, '_block', bl );
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
+      checkRedefinition( elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -1330,7 +1341,7 @@ function getDefinerFunctions( model ) {
       name: { path: splitIntoPath( location, entityName ), absolute: entityName, location },
       location,
       elements,
-      $inferred: 'aspect-composition',
+      $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
       setLink( art, '_origin', target );
@@ -1958,24 +1969,6 @@ function getDefinerFunctions( model ) {
     }
   }
 
-  // TODO: move to "init" phase
-  /**
-   * Check whether redefinitions of the given artifact name exist and
-   * adapt to `targetAspect`.
-   *
-   * @param {string} name
-   */
-  function preProcessArtifact( name ) {
-    const art = model.definitions[name];
-    if (Array.isArray(art.$duplicates)) {
-      // A definition name containing a `.` is not invalid (TODO: starting or
-      // ending with a dot is invalid and could be checked here)
-      for (const a of art.$duplicates)
-        checkRedefinitions( a, name, 'definitions' );
-    }
-    checkRedefinitions( art, name, 'definitions' );
-  }
-
   /**
    * Process "composition of" artifacts.
    *
@@ -2111,7 +2104,7 @@ function getDefinerFunctions( model ) {
       name: { path: splitIntoPath( location, absolute ), absolute, location },
       location: base.location,
       elements,
-      $inferred: 'localized',
+      $inferred: 'localized-entity',
     };
     const locale = {
       name: { location, id: 'locale' },
@@ -2212,7 +2205,7 @@ function getDefinerFunctions( model ) {
       name: { location, id: 'texts' },
       kind: 'element',
       location,
-      $inferred: 'localized-texts',
+      $inferred: 'localized',
       type: augmentPath( location, 'cds.Composition' ),
       cardinality: { targetMax: { literal: 'string', val: '*', location }, location },
       target: augmentPath( location, textsName ),
@@ -2227,7 +2220,7 @@ function getDefinerFunctions( model ) {
       name: { location, id: 'localized' },
       kind: 'element',
       location,
-      $inferred: 'localized-texts',
+      $inferred: 'localized',
       type: augmentPath( location, 'cds.Association' ),
       target: augmentPath( location, textsName ),
       on: augmentEqual( location, 'localized', keys ),
@@ -2316,36 +2309,6 @@ function mergeI18nBlocks( model ) {
   }
 }
 
-/**
- * Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
- * locations).
- *
- * @param {XSN.Path} path
- */
-function pathName(path) {
-  return path.map( id => id.id ).join('.');
-}
-
-/**
- * Generates an XSN path out of the given name. Path segments are delimited by a dot.
- * Each segment will have the given location assigned.
- *
- * @param {CSN.Location} location
- * @param {string} name
- * @returns {XSN.Path}
- */
-function splitIntoPath( location, name ) {
-  return name.split('.').map( id => ({ id, location }) );
-}
-
-/**
- * @param {CSN.Location} location
- * @param  {...any} args
- */
-function augmentPath( location, ...args ) {
-  return { path: args.map( id => ({ id, location }) ), location };
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)
@@ -2374,9 +2337,4 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
 // these function could be used to a future lib/compiler/utils.js, but DO NOT
 // SHARE with utility functions for CSN processors
 
-module.exports = {
-  define: model => getDefinerFunctions( model ).define(),
-  getDefinerFunctions,
-  augmentPath,
-  splitIntoPath,
-};
+module.exports = { define };