@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/language/language.g4

@@ -721,16 +721,21 @@ aspectDef[ art, outer ] locals[ name = {} ]
         )*
       )?
     )?
-    '{' { $art.elements = this.createDict(); }
-    ( elementDef[ $art ]* )
-    '}' { this.finalizeDictOrArray( $art.elements ); }
-    // TODO: action definitions in a specific section?
-    (
-      ACTIONS '{' { $art.actions = this.createDict(); }
-      actionFunctionDef[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.actions ); }
-    )?
-    optionalSemi
+    ( // `aspect MyAspect {};`
+      '{' { $art.elements = this.createDict(); }
+      ( elementDef[ $art ]* )
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      // TODO: action definitions in a specific section?
+      (
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+      )?
+      optionalSemi
+    | // `aspect MyAspect;`, e.g. for annotation aspects.
+      { this.aspectWithoutElements( $art ); }
+      requiredSemi
+    )
   ;
 
 typeDef[ art, outer ] locals[ name = {} ]
@@ -751,7 +756,7 @@ extendType[ art, outer ] locals[ name = {} ]
     { $art.expectedKind = 'type'; $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
-    extendWithOptElements[ $art, $art ]
+    extendWithOptElementsOrType[ $art, $art ]
   ;
 
 annotationDef[ art, outer ] locals[ name = {} ]
@@ -840,11 +845,16 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
+      |
+        // extend Art with (length: 10);
+        // `with` is required, or we could have `extend String(length:10);`.
+        typeNamedArgList[ $art ]
+        requiredSemi
       )
     )
   ;
 
-extendWithOptElements[ art ]
+extendWithOptElementsOrType[ art ]
   :
     WITH { this.noSemicolonHere(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
@@ -857,6 +867,10 @@ extendWithOptElements[ art ]
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
+    |
+      // extend type|element Art with (length: 10);
+      typeNamedArgList[ $art ]
+      requiredSemi
     |
       requiredSemi
     )
@@ -1066,12 +1080,12 @@ mixinElementDef[ outer ] locals[ art = {} ]
       |
         typeRefOptArgs[ $art ]
         ( as='=' expression
-          { this.notSupportedYet( 'Calculated fields are not supported yet', $as ); }
+          { this.error( 'syntax-unsupported-field', $as ); }
         )?
       )
     |
       as='=' expression
-      { this.notSupportedYet( 'Calculated fields are not supported yet', $as ); }
+      { this.error( 'syntax-unsupported-field', $as ); }
     )
     requiredSemi
   ;
@@ -1090,8 +1104,7 @@ elementDefInner[ art, outer, allowEq ]
     ( masked=MASKED
       {
         $art.masked = this.valueWithTokenLocation( true, $masked ) ;
-        this.message( 'syntax-invalid-masked', $masked, { keyword: 'masked' },
-                      'Keyword $(KEYWORD) not supported' );
+        this.message( 'syntax-unsupported-masked', $masked, { keyword: 'masked' } );
       }
     )?
     // TODO: order?
@@ -1203,7 +1216,7 @@ elementDefInner[ art, outer, allowEq ]
       eq='=' e=expression       // never introduce AS as syntax variant of '='
       {
         if (!$allowEq || $e.expr && !$e.expr.literal )
-          this.notSupportedYet( 'Calculated fields are not supported yet', $eq );
+          this.error( 'syntax-unsupported-field', $eq );
         else if ($e.expr)
           $art.value = $e.expr;
       }
@@ -1220,7 +1233,7 @@ extendElement[ art, outer ]
     ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
     name=ident['Element']
     { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
-    extendWithOptElements[ $art, $art ]
+    extendWithOptElementsOrType[ $art, $art ]
   ;
 
 selectItemDef[ outer ] locals[ art ]
@@ -1246,19 +1259,20 @@ selectItemDefBody[ art, outer ]
       e=expression { $art.value = $e.expr; }
       // we cannot use 'condition' instead, as long as we allow aliases without
       // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
-      ( AS n1=ident['Item'] { $art.name = $n1.id }
+      ( as=AS n1=ident['Item'] { $art.name = $n1.id }
       | n2=ident['Item'] { $art.name = this.fragileAlias( $n2.id, true ); }
       | { if (this.getCurrentToken().text !== '.') this.classifyImplicitName( 'Item', $e.expr ); }
       )
-      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] ); }
+      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] );
+        else if ($art.name) this.excludeExpected( ["'.'"] );
+      }
       (
-        { if ($art.value && !$art.value.path) this.reportExpandInline( 'expand' ); }
+        { this.reportExpandInline( $art, false ); }
         selectItemInlineList[ $art, 'expand' ]
         excludingClause[ $art ]?
         // TODO: we might alternatively allow AS here
       |
-        // TODO: complain if AS has been used - or in definer?
-        { if ($art.value && !$art.value.path) this.reportExpandInline( 'inline' ); }
+        { this.reportExpandInline( $art, $as || this._input.LT(-1) ); }
         DOTbeforeBRACE          // ...orASTERISK
         (
           selectItemInlineList[ $art, 'inline' ]
@@ -1384,7 +1398,7 @@ elementProperties[ elem ]
     nullability[ $elem ]?
   |
     eq='='
-    { this.notSupportedYet( 'Calculated fields are not supported yet', $eq ); }
+    { this.error( 'syntax-unsupported-field', $eq ); }
     expression
   ;
 
@@ -1799,6 +1813,16 @@ typeRefArgs[ art ]
     ')'{ this.finalizeDictOrArray( $art['$'+'typeArgs']); }
   ;
 
+typeNamedArgList[ art ]
+  :
+    paren='('
+    typeNamedArg[ $art ]
+    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+      typeNamedArg[ $art ]
+    )*
+    ')'
+  ;
+
 typeNamedArg[ art ] locals[ arg = '' ]
   :
     name=ident['paramname']
@@ -2206,7 +2230,7 @@ conditionTerm returns [ cond ]
       { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [
           { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' }
         ] };
-        this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
       }
     |
       ep=valuePath[ 'ref' ]
@@ -2330,7 +2354,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       ne=NEW nqp=valuePath[ 'ref', null] // token rewrite for NEW
       // please note: there will be no compiler-supported code completion after NEW
       { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
-        this.notSupportedYet( $ne ); }
+        this.error( 'syntax-unsupported-new', $ne, { keyword: $ne.text }, '$(KEYWORD) is not supported' ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
       { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
@@ -2343,7 +2367,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         { $expr = $vp.qp;; $expr.scope = 'param'; }
       | pp=Number
         { $expr = { param: this.numberLiteral( $pp ), scope: 'param' };
-          this.csnParseOnly( 'Positional parameter ":' + $pp.text + '" is not supported', $pp );
+          this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', name: ':' + $pp.text } );
         }
       )
     |
@@ -2351,7 +2375,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       // if we have an HideAlternatives here, we would block it to use it in
       // parallel to an expression (would produce adaptivePredict() otherwise)
       { $expr = { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' };
-        this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
       }
     |
       open='('
@@ -2641,8 +2665,9 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
             const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
             if ($ctx.upTo) item.upTo = $upTo.val;
             $assignment.val.push( item );
-            if ($seenEllipsis === true) // TODO: adapt msg to UP TO
-              this.error( 'syntax-unexpected-ellipsis', $e, { '#': 'std', code: '...' } );
+            if ($seenEllipsis === true)
+              this.error( 'syntax-unexpected-ellipsis', $e,
+                          { '#': 'duplicate', code: '...', keyword: 'up to' } );
             else
               $seenEllipsis = !$ctx.upTo || 'upTo';
           }}
@@ -2652,9 +2677,8 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
     cb=']'
     {
       if ($seenEllipsis === 'upTo')
-        this.error( 'syntax-expecting-ellipsis', $cb, // at closing bracket
-                    { code: '... up to', newcode: '...' },
-                   'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
+        this.error( 'syntax-missing-ellipsis', $cb, // at closing bracket
+                    { code: '... up to', newcode: '...' } );
     }
   |
     v1=literalValue { Object.assign( $assignment, $v1.val ); }

package/lib/language/multiLineStringParser.js

@@ -25,9 +25,9 @@ const {
  *                             of whitespace characters removed.
  */
 function stripIndentation(str) {
-  if (str === '') {
-    return ['', 0];
-  }
+  if (str === '')
+    return [ '', 0 ];
+
 
   // Note: We have to check all newline characters, as the string is not normalized, yet.
   const lines = str.split(cdlNewLineRegEx);
@@ -39,20 +39,19 @@ function stripIndentation(str) {
     // If there is a trailing line break, it means that ``` is on newline and
     // therefore the indentation to remove is 0.
     // Remove the last newline, which may be CRLF.
-    return [lines.slice(0, -1).join('\n'), 0];
+    return [ lines.slice(0, -1).join('\n'), 0 ];
   }
 
   const minIndent = lines.reduce((min, line, index) => {
     // Note: Last line is the line containing ```.  There, we always count the indentation,
     //       even if blank.  For all other lines, blank lines are ignored.
-    if (isWhitespaceOrNewLineOnly(line) && index !== (n-1))
+    if (isWhitespaceOrNewLineOnly(line) && index !== (n - 1))
       return min;
 
     let count = 0;
     const length = Math.min(min, line.length);
-    while (count < length && isWhitespaceCharacterNoNewline(line[count])) {
+    while (count < length && isWhitespaceCharacterNoNewline(line[count]))
       count++;
-    }
     return Math.min(min, count);
   }, Number.MAX_SAFE_INTEGER);
 
@@ -63,10 +62,10 @@ function stripIndentation(str) {
   }
 
   // Remove trailing last line, if there was nothing else in that line.
-  if (lines[n-1] === '')
+  if (lines[n - 1] === '')
     lines.pop();
 
-  return [lines.join('\n'), minIndent];
+  return [ lines.join('\n'), minIndent ];
 }
 
 class MultiLineStringParser {
@@ -75,9 +74,9 @@ class MultiLineStringParser {
     this.token = token;
     this.str = token.text; // Copy because .text is a getter
 
-    if (this.str[0] !== '`' || this.str[this.str.length-1] !== '`') {
+    if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
+      // eslint-disable-next-line max-len
       throw new Error('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
-    }
 
     this.output = [];
     this.isTextBlock = this.str.startsWith('```');
@@ -90,7 +89,8 @@ class MultiLineStringParser {
     if (this.isTextBlock) {
       this.i = 3;
       this.end = this.str.length - 3;
-    } else {
+    }
+    else {
       this.i = 1;
       this.end = this.str.length - 1;
     }
@@ -102,9 +102,8 @@ class MultiLineStringParser {
    * @return {string}
    */
   parse() {
-    if (this.str.length === 2) {
+    if (this.str.length === 2)
       return ''; // Nothing to do: ``
-    }
 
     if (this.isTextBlock) {
       // If there are no line breaks, emit an error as normal single-back-tick
@@ -112,7 +111,7 @@ class MultiLineStringParser {
       // there is no text without at least one line break.
       if (!cdlNewLineRegEx.test(this.str)) {
         const loc = this._locationForCharacters(this.end, 1);
-        this.parser.message('syntax-invalid-text-block', loc);
+        this.parser.error('syntax-invalid-text-block', loc);
         return '';
       }
       this._skipOptionalLanguageIdentifierLine();
@@ -135,7 +134,7 @@ class MultiLineStringParser {
     // Note: Index is at first character of string
 
     do {
-      switch(this._current()) {
+      switch (this._current()) {
         case this._matchLineBreakAtCurrentChar():
           this.output.push('\n');
           break;
@@ -146,8 +145,8 @@ class MultiLineStringParser {
         case '$':
           if (this._lookahead() === '{') {
             const loc = this._locationForCharacters(this.i, 2);
-            this.parser.message('syntax-missing-escape', loc,
-              { '#': 'placeholder', code: '${', newcode: '\\${' });
+            this.parser.error('syntax-missing-escape', loc,
+                              { '#': 'placeholder', code: '${', newcode: '\\${' });
           }
           this.output.push(this.str[this.i]);
           break;
@@ -155,7 +154,7 @@ class MultiLineStringParser {
           this.output.push(this.str[this.i]);
           break;
       }
-    } while(this._move());
+    } while (this._move());
 
     return this.output.join('');
   }
@@ -166,27 +165,27 @@ class MultiLineStringParser {
    * @private
    */
   _innerEscape() {
-    switch(this._current()) {
+    switch (this._current()) {
       case this._matchLineBreakAtCurrentChar():
         // Don't add to output -> line break is escaped
         break;
       case 'b': // backspace
-        this.output.push(`\b`);
+        this.output.push('\b');
         break;
       case 'f': // form feed
-        this.output.push(`\f`);
+        this.output.push('\f');
         break;
       case 'v': // vertical tabulator
-        this.output.push(`\v`);
+        this.output.push('\v');
         break;
       case 'r': // carriage return
-        this.output.push(`\r`);
+        this.output.push('\r');
         break;
       case 'n': // line feed
-        this.output.push(`\n`);
+        this.output.push('\n');
         break;
       case 't': // tab
-        this.output.push(`\t`);
+        this.output.push('\t');
         break;
       case '\\':
       case '"':
@@ -206,21 +205,23 @@ class MultiLineStringParser {
         break;
       case '0': // null terminator
         if (!/^\d$/.test(this._lookahead())) {
-          this.output.push(`\0`);
+          this.output.push('\0');
           break;
         }
         // Let the default case handle octal representation.
         // fallthrough
       default: {
         this.output.push(this._current());
-        const loc = this._locationForCharacters(this.i-1, 2);
+        const loc = this._locationForCharacters(this.i - 1, 2);
         if (/\s/.test(this._current())) {
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'whitespace' });
-        } else if (/\d/.test(this._current())) {
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'octal' });
-        } else {
-          const code = this._makeCode('\\' + this._current());
-          this.parser.message('syntax-unknown-escape', loc,  { '#': 'std', code });
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'whitespace' });
+        }
+        else if (/\d/.test(this._current())) {
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'octal' });
+        }
+        else {
+          const code = this._makeCode(`\\${ this._current() }`);
+          this.parser.message('syntax-unknown-escape', loc, { '#': 'std', code });
         }
         break;
       }
@@ -239,9 +240,9 @@ class MultiLineStringParser {
     // syntax variant as the first invalid code point is \u{110000}
     // and an empty `codePoint` is only possible with the braced variant.
     const reportInvalidCodePoint = () => {
-      const code = this._makeCode(`\\u{${codePoint}}`);
-      const loc = this._locationForCharacters(this.i-codePoint.length, codePoint.length);
-      this.parser.message('syntax-invalid-escape', loc, { '#': 'codepoint', code });
+      const code = this._makeCode(`\\u{${ codePoint }}`);
+      const loc = this._locationForCharacters(this.i - codePoint.length, codePoint.length);
+      this.parser.error('syntax-invalid-escape', loc, { '#': 'codepoint', code });
     };
 
     const n = Number.parseInt(codePoint, 16);
@@ -252,7 +253,8 @@ class MultiLineStringParser {
 
     try {
       this.output.push(String.fromCodePoint(n));
-    } catch (e) {
+    }
+    catch (e) {
       // RangeError is thrown if number isn't a valid code point
       reportInvalidCodePoint();
     }
@@ -275,18 +277,20 @@ class MultiLineStringParser {
       if (!this._eos() && /^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
-      } else {
+      }
+      else {
         break;
       }
     }
 
     if (codePoint.length === count) {
       this._parseHexCodePoint(codePoint);
-    } else {
-      const loc = this._locationForCharacters(this.i+1, 1);
-      const code = this._eos(this.i+1) ? `\\${mode}${codePoint}` : `\\${mode}${codePoint}${this._lookahead()}`;
-      this.parser.message('syntax-invalid-escape', loc,
-        { '#': 'hex-count', number: count, code: this._makeCode(code) });
+    }
+    else {
+      const loc = this._locationForCharacters(this.i + 1, 1);
+      const code = this._eos(this.i + 1) ? `\\${ mode }${ codePoint }` : `\\${ mode }${ codePoint }${ this._lookahead() }`;
+      this.parser.error('syntax-invalid-escape', loc,
+                        { '#': 'hex-count', number: count, code: this._makeCode(code) });
     }
   }
 
@@ -305,14 +309,17 @@ class MultiLineStringParser {
       if (/^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
-      } else if (this._lookahead() === '}') {
+      }
+      else if (this._lookahead() === '}') {
         break;
-      } else if (!this._eos(this.i+1)) {
-        const loc = this._locationForCharacters(this.i+1, 1); // Point to the exact character
-        const code = this._makeCode(`\\u{${codePoint}${this._lookahead()}…}`);
-        this.parser.message('syntax-invalid-escape', loc, { '#': 'unicode-hex', code });
+      }
+      else if (!this._eos(this.i + 1)) {
+        const loc = this._locationForCharacters(this.i + 1, 1); // Point to the exact character
+        const code = this._makeCode(`\\u{${ codePoint }${ this._lookahead() }…}`);
+        this.parser.error('syntax-invalid-escape', loc, { '#': 'unicode-hex', code });
         return;
-      } else {
+      }
+      else {
         break;
       }
     }
@@ -320,9 +327,10 @@ class MultiLineStringParser {
     if (this._lookahead() === '}') {
       this._move();
       this._parseHexCodePoint(codePoint);
-    } else {
+    }
+    else {
       const loc = this._locationForCharacters(this.i, 1);
-      this.parser.message('syntax-invalid-escape', loc, { '#': 'unicode-brace' });
+      this.parser.error('syntax-invalid-escape', loc, { '#': 'unicode-brace' });
     }
   }
 
@@ -333,7 +341,7 @@ class MultiLineStringParser {
    * @private
    */
   _skipOptionalLanguageIdentifierLine() {
-    while(!this._eos()) {
+    while (!this._eos()) {
       switch (this._current()) {
         case this._matchLineBreakAtCurrentChar():
           this._move();
@@ -342,7 +350,7 @@ class MultiLineStringParser {
           // Do not allow an escape in the language identifier. If at the line's end, users
           // may expect the identifier to span more than the first line, which is _not_ the case.
           const loc = this._locationForCharacters(this.i, 1);
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'language-identifier' });
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'language-identifier' });
           this._move();
           break;
         }
@@ -367,7 +375,7 @@ class MultiLineStringParser {
    */
   _matchLineBreakAtCurrentChar() {
     // Only increase line number for \n, because ANTLR does the same
-    switch(this._current()) {
+    switch (this._current()) {
       case '\r':
         if (this._lookahead() === '\n') {
           this._move(); // \r\n is normalized
@@ -382,6 +390,7 @@ class MultiLineStringParser {
       case '\u2028': // LS
       case '\u2029': // PS
         return this._current();
+      default: break;
     }
     return null;
   }
@@ -419,7 +428,7 @@ class MultiLineStringParser {
    * @returns {string}
    */
   _lookahead() {
-    return this.str[this.i+1];
+    return this.str[this.i + 1];
   }
 
   /**
@@ -439,7 +448,7 @@ class MultiLineStringParser {
    * @returns {string}
    */
   _previous() {
-    return this.str[this.i-1];
+    return this.str[this.i - 1];
   }
 
   /**
@@ -455,8 +464,12 @@ class MultiLineStringParser {
       file: this.parser.filename,
       line: this.token.line + this._lineInString,
       endLine: this.token.line + this._lineInString,
-      col: this._lineInString > 0 ? i - this._currentLineBreakIndex + this._indentation : this.token.column + i + 1,
-      endCol: this._lineInString > 0 ? i - this._currentLineBreakIndex + width + this._indentation :  this.token.column + i + width + 1,
+      col: this._lineInString > 0
+        ? i - this._currentLineBreakIndex + this._indentation
+        : this.token.column + i + 1,
+      endCol: this._lineInString > 0
+        ? i - this._currentLineBreakIndex + width + this._indentation
+        : this.token.column + i + width + 1,
     };
   }
 
@@ -468,7 +481,7 @@ class MultiLineStringParser {
    * @param {string} code
    * @private
    */
-  _makeCode(code) {
+  _makeCode(code) { // eslint-disable-line class-methods-use-this
     // For characters that may be rendered as newline,
     // see <https://www.unicode.org/reports/tr14/tr14-32.html>.
     //
@@ -484,9 +497,8 @@ class MultiLineStringParser {
     //
     // For Visualization, see <https://en.wikipedia.org/wiki/Newline#Unicode>
     //   U+23CE: ⏎
-
-    const allPossibleNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
-    return code.replace(allPossibleNewLineCharacters, '\u{23CE}');
+    const allNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
+    return code.replace(allNewLineCharacters, '\u{23CE}');
   }
 }
 

package/lib/main.d.ts

@@ -786,15 +786,12 @@ declare namespace compiler {
    */
   export type CdlResult = {
     /**
-     * Rendered model, excluding not-applied extensions.
+     * Rendered model, including extensions.
      */
     model?: string
     /**
-     * Rendered extend/annotate statements of `csn.extensions`
-     */
-    unappliedExtensions?: string
-    /**
-     * Rendered csn.namespace property + using directives.
+     * Rendered `csn.namespace` property + using directives.
+     * Useful to keep the `csn.namespace` property when re-compiling the to.cdl() result.
      */
     namespace?: string
   }

package/lib/main.js

@@ -115,6 +115,7 @@ module.exports = {
       functions: Object.freeze([ ...keywords.cdl_functions ] ),
     }),
     sql: Object.assign((...args) => snapi.sql(...args), {
+      migration: (...args) => snapi.sql.migration(...args),
       sqlite: {
         keywords: Object.freeze([ ...keywords.sqlite ] )
       },

package/lib/model/.eslintrc.json

@@ -0,0 +1,13 @@
+{
+  "root": true,
+  "extends": "../../.eslintrc-ydkjsi.json",
+  "rules": {
+    "max-len": [ "error", {
+      "code": 180, // TODO: Remove
+      "tabWidth": 2,
+      "ignoreRegExpLiterals": false,
+      "ignoreStrings": false,
+      "ignoreTemplateLiterals": true
+    }]
+  }
+}

package/lib/model/api.js

@@ -2,6 +2,8 @@
 
 // Do not change at will - they are in the compiler API!
 
+'use strict';
+
 /**
  * Dictionary of default traversal functions for function `traverseCsn`.
  * It maps CSN property names to functions which are used by default
@@ -23,8 +25,8 @@ const defaultFunctions = {
   actions: dictionary,
   mixin: dictionary,
   definitions: dictionary,
-  '$': () => { /*  do not traverse properties starting with '$' */},
-}
+  $: () => { /*  do not traverse properties starting with '$' */ },
+};
 
 /**
  * Traverse the CSN node `csn`.