@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/model/csnUtils.js

@@ -36,7 +36,7 @@ const version = require('../../package.json').version;
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils(model) {
-  const { artifactRef, inspectRef, effectiveType } = csnRefs(model);
+  const { artifactRef, inspectRef, effectiveType, getOrigin } = csnRefs(model);
 
   return {
     getCsnDef,
@@ -58,8 +58,137 @@ function getUtils(model) {
     inspectRef,
     artifactRef,
     effectiveType,
+    get$combined,
+    getOrigin,
   };
 
+  /**
+   * Compute and return $combined for the given query.
+   *
+   * @param {CSN.Query} query
+   * @returns {object}
+   */
+  function get$combined(query) {
+    const sources = getSources(query);
+    return sources;
+
+    /**
+     * Get the union of all elements from the from clause
+     * - descend into unions, following the lead query
+     * - merge all queries in case of joins
+     * - follow subqueries
+     *
+     * @param {CSN.Query} query Query to check
+     * @returns {object} Map of sources
+     */
+    function getSources(query, isSubquery=false) {
+      // Remark CW: better just a while along query.SET.args[0]
+      if (query.SET) {
+        if (query.SET.args[0].SELECT && query.SET.args[0].SELECT.elements)
+          return mergeElementsIntoMap(Object.create(null), query.SET.args[0].SELECT.elements, query.SET.args[0].$location);
+
+        return getSources(query.SET.args[0], isSubquery);
+      }
+      else if (query.SELECT) {
+        if (query.SELECT.from.args) {
+          return walkArgs(query.SELECT.from.args);
+        }
+        else if (query.SELECT.from.ref) {
+          let art = artifactRef(query.SELECT.from);
+
+          if(art.target)
+            art = artifactRef(art.target);
+
+          if(isSubquery && !query.SELECT.elements)
+            throw new Error('Expected subquery to have .elements');
+
+          return mergeElementsIntoMap(Object.create(null), isSubquery ? query.SELECT.elements : art.elements, art.$location,
+            query.SELECT.from.as || query.SELECT.from.ref[query.SELECT.from.ref.length - 1],
+            query.SELECT.from.ref[query.SELECT.from.ref.length - 1] || query.SELECT.from.as );
+        }
+        else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
+          return getSources(query.SELECT.from, true);
+        }
+      }
+
+      function walkArgs(args) {
+        let elements = Object.create(null);
+        for (const arg of args) {
+          if (arg.args) {
+            elements = mergeElementMaps(elements, walkArgs(arg.args));
+          }
+          else if (arg.ref) {
+            const art = artifactRef(arg);
+            elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || arg.ref[arg.ref.length - 1], arg.ref[arg.ref.length - 1] || arg.as);
+          }
+          else if (arg.SELECT || arg.SET) {
+            elements = mergeElementMaps(elements, getSources(arg));
+          }
+        }
+
+        return elements;
+      }
+
+      return {};
+
+      /**
+       * Merge two maps of elements together
+       *
+       * @param {object} mapA Map a - will be returned
+       * @param {object} mapB Map b - will not be returned
+       * @returns {object} mapA
+       */
+      function mergeElementMaps(mapA, mapB) {
+        for (const elementName in mapB) {
+          if (!mapA[elementName])
+            mapA[elementName] = [];
+
+          mapB[elementName].forEach(e => mapA[elementName].push(e));
+        }
+
+        return mapA;
+      }
+
+      /**
+       * Merge elements into an existing map
+       *
+       * @param {any} existingMap map to merge into - will be returned
+       * @param {object} elements elements to merge into the map
+       * @param {CSN.Location} $location $location of the elements - where they come from
+       * @param {any} [parent] Name of the parent of the elements, alias before ref
+       * @param {any} [error_parent] Parent name to use for error messages, ref before alias
+       * @returns {object} existingMap
+       */
+      function mergeElementsIntoMap(existingMap, elements, $location, parent, error_parent) {
+        for (const elementName in elements) {
+          const element = elements[elementName];
+          if (!existingMap[elementName])
+            existingMap[elementName] = [];
+
+
+          existingMap[elementName].push({
+            element, name: elementName, source: $location, parent: getBaseName(parent), error_parent,
+          });
+        }
+
+        return existingMap;
+      }
+    }
+
+      /**
+   * Return the name part of the artifact name - no namespace etc.
+   * @param {string|object} name Absolute name of the artifact
+   */
+    function getBaseName(name) {
+      if (!name)
+        return name;
+
+      if (name.id)
+        return name.id.substring( name.id.lastIndexOf('.')+1 );
+
+      return name.substring( name.lastIndexOf('.')+1 )
+    }
+  }
 
 
   /**
@@ -328,45 +457,54 @@ function getUtils(model) {
       return resultNode;
     }
   }
-
-  // Resolve to the final type of a type, that means follow type chains, references to other types or
-  // elements a.s.o
-  // Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
-  // Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
-  // else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
-  // e.g. given the following model
-  //     type bar: S.foo;
-  //     type s1 {
-  //       s: s2;
-  //     };
-  //     type s2 {
-  //       u: type of S.e:t;
-  //     }
-  //     service S {
-  //       type foo: type of S.e:i.j1;
-  //       entity e {
-  //         key i: { j1: Integer };
-  //         t: bar;
-  //         v: s1;
-  //         x: blutz.s.u;
-  //       };
-  //       type blutz: S.e.v;
-  //       view V as select from e {
-  //         1+1 as i: bar,
-  //       };
-  //       type tt: type of V:i;
-  //    }
-  // the following calls will all return 'cds.Integer'
-  //     getFinalBaseType('S.tt')
-  //     getFinalBaseType('S.e',['i','j1'])
-  //     getFinalBaseType('S.e',['t'])
-  //     getFinalBaseType('S.e',['x'])
-  //     getFinalBaseType('S.blutz',['s', 'u'])
-  // Types are always resolved as far as possible. A type name which has no further definition is simply returned.
-  // Composed types (structures, entities, vies, ...) are returned as type objects, if not drilled down into
-  // the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
-  // no type (e.g. expr in a view without explicit type) returns 'null'
-  function getFinalBaseType(type, path = [], cycleCheck = undefined) {
+  
+  
+  /**
+   * Resolve to the final type of a type, that means follow type chains, references to other types or
+   * elements a.s.o
+   * Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
+   * Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
+   * else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
+   * e.g. given the following model
+   *     type bar: S.foo;
+   *     type s1 {
+   *       s: s2;
+   *     };
+   *     type s2 {
+   *       u: type of S.e:t;
+   *     }
+   *     service S {
+   *       type foo: type of S.e:i.j1;
+   *       entity e {
+   *         key i: { j1: Integer };
+   *         t: bar;
+   *         v: s1;
+   *         x: blutz.s.u;
+   *       };
+   *       type blutz: S.e.v;
+   *       view V as select from e {
+   *         1+1 as i: bar,
+   *       };
+   *       type tt: type of V:i;
+   *    }
+   * the following calls will all return 'cds.Integer'
+   *     getFinalBaseType('S.tt')
+   *     getFinalBaseType('S.e',['i','j1'])
+   *     getFinalBaseType('S.e',['t'])
+   *     getFinalBaseType('S.e',['x'])
+   *     getFinalBaseType('S.blutz',['s', 'u'])
+   * Types are always resolved as far as possible. A type name which has no further definition is simply returned.
+   * Composed types (structures, entities, views, ...) are returned as type objects, if not drilled down into
+   * the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
+   * no type (e.g. expr in a view without explicit type) returns 'null'
+   * 
+   * @param {string|object} type Type - either string or ref
+   * @param {CSN.Path} path 
+   * @param {WeakMap} [resolved=new WeakMap()] WeakMap containing already resolved refs - if a ref is not cached, it will be resolved JIT
+   * @param {object} [cycleCheck] Dictionary to remember already resolved types - to be cycle-safe 
+   * @returns 
+   */
+  function getFinalBaseType(type, path = [], resolved = new WeakMap(), cycleCheck = undefined) {
     if (!type)
       return type;
     if (typeof(type) === 'string') {
@@ -384,24 +522,24 @@ function getUtils(model) {
       }
       let definedType = model.definitions[type];
       if (definedType && definedType.type)
-        return getFinalBaseType(definedType.type, path, cycleCheck);
+        return getFinalBaseType(definedType.type, path, resolved, cycleCheck);
       else
-        return getFinalBaseType(definedType, path, cycleCheck);
+        return getFinalBaseType(definedType, path, resolved, cycleCheck);
     }
     else if (typeof(type) === 'object') {
       if (type.ref) {
         // assert type.ref instanceof Array && type.ref.length >= 1
-        const ref = artifactRef(type);
-        return getFinalBaseType(ref, path, cycleCheck);
+        const ref = resolved.has(type) ? resolved.get(type).art : artifactRef(type);
+        return getFinalBaseType(ref, path, resolved, cycleCheck);
       }
       else if (type.elements) {
         if (path.length) {
           let [e, ...p] = path;
-          return getFinalBaseType(type.elements[e], p, cycleCheck);
+          return getFinalBaseType(type.elements[e], p, resolved, cycleCheck);
         }
       }
       else if (type.type)
-        return (getFinalBaseType(type.type, path, cycleCheck));
+        return (getFinalBaseType(type.type, path, resolved, cycleCheck));
       else if (type.items)
         return type;
       else
@@ -493,12 +631,12 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // Backends rely on the fact that `forEachElement` also goes through all
   // `elements` of the return type (if structured).
   // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
-  if (construct.returns) {
+  if (construct.returns && !iterateOptions.elementsOnly) {
     forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
   }
 
   path = [...path]; // Copy
-  const propsWithMembers = ['elements', 'enum', 'foreignKeys', 'actions', 'params'];
+  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'foreignKeys', 'actions', 'params']);
   propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
 }
 
@@ -922,11 +1060,12 @@ function getElementDatabaseNameOf(elemName, namingConvention) {
  *
  * @param {object} csn CSN to enrich in-place
  * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {Function[]} artifactTransformers Transformations to run on the artifacts, like forEachDefinition
- * @param {Boolean} skipIgnore Wether to skip _ignore elements or not
+ * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
+ * @param {Boolean} [skipIgnore=true] Wether to skip _ignore elements or not
+ * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
  * @returns {object} CSN with transformations applied
  */
-function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true ) {
+function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true, options = {} ) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -959,7 +1098,7 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
       for (let name of Object.getOwnPropertyNames( node )) {
         const trans = transformers[name] || standard;
         if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath);
+          customTransformers[name](node, name, node[name], csnPath, parent, prop);
 
         trans( node, name, node[name], csnPath );
       }
@@ -968,6 +1107,9 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
   }
 
   function dictionary( node, prop, dict ) {
+    // Allow skipping dicts like actions in forHanaNew
+    if(options.skipDict && options.skipDict[prop])
+      return;
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
       standard( dict, name, dict[name] );
@@ -980,8 +1122,11 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
   function definitions( node, prop, dict ) {
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
-      artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-      standard( dict, name, dict[name] );
+      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
+      if(!skip) {
+        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
+        standard( dict, name, dict[name] );
+      }
     }
     if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
       setProp(node, '$' + prop, dict);
@@ -994,10 +1139,14 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
     path.forEach( function step( s, i ) {
       if (s && typeof s === 'object') {
         csnPath.push( i );
-        if (s.args)
-          standard( s, 'args', s.args );
-        if (s.where)
-          standard( s, 'where', s.where );
+        if(options.drillRef) {
+          standard(path, i, s);
+        } else {
+          if (s.args)
+            standard( s, 'args', s.args );
+          if (s.where)
+            standard( s, 'where', s.where );
+        }
         csnPath.pop();
       }
     } );
@@ -1405,6 +1554,32 @@ function getServiceNames(csn) {
   return result;
 }
 
+/**
+ * Check wether the artifact is @cds.persistence.skip
+ * 
+ * @param {CSN.Artifact} artifact 
+ * @returns {Boolean}
+ */
+function isSkipped(artifact) {
+  return hasAnnotationValue(artifact, '@cds.persistence.skip', true)
+}
+
+/**
+ * Walk path in the CSN and return the result.
+ * 
+ * @param {CSN.Model} csn 
+ * @param {CSN.Path} path 
+ * @returns {object} Whatever is at the end of path
+ */
+function walkCsnPath(csn, path) {
+  /** @type {object} */
+  let obj = csn;
+  for(let i = 0; i < path.length; i++){
+    obj = obj[path[i]];
+  }
+
+  return obj;
+}
 
 module.exports = {
   getUtils,
@@ -1444,4 +1619,6 @@ module.exports = {
   getNamespace,
   sortCsnDefinitionsForTests,
   getServiceNames,
+  isSkipped,
+  walkCsnPath,
 };

package/lib/model/enrichCsn.js

@@ -44,11 +44,13 @@ function enrichCsn( csn, options = {} ) {
     targetAspect: simpleRef,
     target: simpleRef,
     includes: simpleRef,
+    $origin,
     // TODO: excluding
     '@': () => { /* ignore annotations */ },
   }
   setLocations( csn, false, null );
-  const { inspectRef, artifactRef, __getCache_forEnrichCsnDebugging } = csnRefs( csn );
+  const { inspectRef, artifactRef, getOrigin, __getCache_forEnrichCsnDebugging } =
+      csnRefs( csn );
   let $$cacheObjectNumber = 0;   // for debugging
   const csnPath = [];
   if (csn.definitions)
@@ -119,6 +121,21 @@ function enrichCsn( csn, options = {} ) {
     //   parent['_' + prop] = e.toString(); }
   }
 
+  function $origin( parent, prop, ref ) {
+    if (options.testMode) {
+      if (Array.isArray( ref ))  // $origin: […], not $origin: {…}
+        parent._origin = refLocation( getOrigin( parent ) );
+    }
+    else {
+      try {
+        if (Array.isArray( ref ))  // $origin: […], not $origin: {…}
+          parent._origin = refLocation( getOrigin( parent ) );
+      } catch (e) {
+        parent._origin = e.toString();
+      }
+    }
+  }
+
   function pathRef( parent, prop, path ) {
     const { links, art, scope, $env } = (() => {
       if (options.testMode)

package/lib/model/revealInternalProperties.js

@@ -76,6 +76,7 @@ function revealInternalProperties( model, name ) {
     _annotate: reveal,
     _deps: dependencyInfo,
     _status: primOrString,       // is a string anyway
+    $messageFunctions: () => '‹some functions›',
   }
   unique_id = 1;
   return revealXsnPath(name, model);
@@ -159,7 +160,7 @@ function revealInternalProperties( model, name ) {
 
   function columns( nodes, query ) {
     // If we will have specified elements, we need another test to see columns in --parse-cdl
-    return nodes && nodes.map( c => (c._parent && c._parent.elements && c.kind !== '$inline')
+    return nodes && nodes.map( c => (c._parent && c._parent.elements)
                                     ? artifactIdentifier( c, query )
                                     : reveal( c, nodes ) );
   }

package/lib/modelCompare/compare.js

@@ -22,17 +22,17 @@ function compareModels(beforeModel, afterModel, options) {
 
   const deletedEntities = Object.create(null);
   const elementAdditions = [];
-  const elementChanges = [];
+  const migrations = []; // element changes/removals or changes of entity properties
 
   // There is currently no use in knowing the added entities only. If this changes, hand in `addedEntities` to `getArtifactComparator` below.
-  forEachDefinition(afterModel, getArtifactComparator(beforeModel, null, null, elementAdditions, elementChanges));       // (, alerts(afterModel))
-  forEachDefinition(beforeModel, getArtifactComparator(afterModel, null, deletedEntities, null, null));       // (, alerts(beforeModel))
+  forEachDefinition(afterModel, getArtifactComparator(beforeModel, null, null, elementAdditions, migrations));
+  forEachDefinition(beforeModel, getArtifactComparator(afterModel, null, deletedEntities, null, null));
 
   const returnObj = Object.create(null);
   returnObj.definitions = afterModel.definitions;
   returnObj.deletions = deletedEntities;
   returnObj.extensions = elementAdditions;
-  returnObj.migrations = elementChanges;
+  returnObj.migrations = migrations;
   return returnObj;
 }
 
@@ -59,35 +59,45 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
 }
 
-function getArtifactComparator(otherModel, addedEntities, deletedEntities, elementAdditions, elementChanges) {                              // (, alerts)
-  return function compareArtifacts(artifact, name) {                                   // (, topKey, path)   topKey == 'definitions'
+function getArtifactComparator(otherModel, addedEntities, deletedEntities, elementAdditions, migrations) {
+  return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
       forEachMember(artifact, getElementComparator(otherArtifact, elements));
       if (Object.keys(elements).length > 0) {
-        elementAdditions.push({
-          extend: name,
-          elements: elements
-        });
+        elementAdditions.push(addedElements(name, elements));
       }
     }
-    function removeOrChangeElements() {
+    function changePropsOrRemoveOrChangeElements() {
+      const relevantProperties = ['doc'];
+      const changedProperties = {};
+
       const removedElements = {};
       const changedElements = {};
-      const modification = { migrate: name };
+
+      const migration = { migrate: name };
+
+      relevantProperties.forEach(prop => {
+        if (artifact[prop] !== otherArtifact[prop]) {
+          changedProperties[prop] = changedElement(artifact[prop], otherArtifact[prop] || null);
+        }
+      });
+      if (Object.keys(changedProperties).length > 0) {
+        migration.properties = changedProperties;
+      }
 
       forEachMember(otherArtifact, getElementComparator(artifact, removedElements));
       if (Object.keys(removedElements).length > 0) {
-        modification.remove = removedElements;
+        migration.remove = removedElements;
       }
 
       forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements));
       if (Object.keys(changedElements).length > 0) {
-        modification.change = changedElements;
+        migration.change = changedElements;
       }
 
-      if (modification.remove || modification.change) {
-        elementChanges.push(modification);
+      if (migration.properties || migration.remove || migration.change) {
+        migrations.push(migration);
       }
     }
 
@@ -124,8 +134,8 @@ function getArtifactComparator(otherModel, addedEntities, deletedEntities, eleme
     if (elementAdditions) {
       addElements();
     }
-    if (elementChanges) {
-      removeOrChangeElements();
+    if (migrations) {
+      changePropsOrRemoveOrChangeElements();
     }
   };
 }
@@ -139,8 +149,8 @@ function isPersistedAsTable(artifact) {
       && !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
-function getElementComparator(otherArtifact, addedElements = null, changedElements = null) {                    // (, alerts)
-  return function compareElements(element, name) {                                     // (, topKey, path)   topKey == 'elements'
+function getElementComparator(otherArtifact, addedElements = null, changedElements = null) {
+  return function compareElements(element, name) {
     if (element._ignore) {
       return;
     }
@@ -209,6 +219,13 @@ function typeParametersChanged(element, otherElement) {
   return !deepEqual(element, otherElement, (key, depth) => !(depth === 0 && key === 'type'));
 }
 
+function addedElements(entity, elements) {
+  return {
+    extend: entity,
+    elements
+  };
+}
+
 function changedElement(element, otherElement) {
   return {
     old: otherElement,

package/lib/optionProcessor.js

@@ -37,8 +37,10 @@ optionProcessor
   .option('    --test-mode')
   .option('    --test-sort-csn')
   .option('    --doc-comment')
+  .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --defaultStringLength <length>')
+  .option('    --no-recompile')
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc <command> [options] <files...>
@@ -88,12 +90,12 @@ optionProcessor
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
-                              keylessManagedAssoc
                               foreignKeyConstraints
                               addTextsLanguageAssoc
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              windowFunctions
        --constraints-not-enforced  If this option is supplied, referential constraints are NOT ENFORCED
                                    This option is also applied to result of "cdsc manageConstraints"
        --constraints-not-validated If this option is supplied, referential constraints are NOT VALIDATED
@@ -124,8 +126,11 @@ optionProcessor
                             OData CSN, CDL order and more.  When --test-mode is enabled, this
                             option is implicitly enabled as well.
        --doc-comment        Preserve /** */ comments at annotation positions as doc property in CSN
+       --add-texts-language-assoc   In generated texts entities, add association "language"
+                                    to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
-
+       --no-recompile       Don't recompile in case of internal errors
+  
   Commands
     H, toHana [options] <files...>              Generate HANA CDS source files
     O, toOdata [options] <files...>             Generate ODATA metadata and annotations
@@ -335,7 +340,7 @@ optionProcessor.command('manageConstraints')
 
 optionProcessor.command('toCsn')
   .option('-h, --help')
-  .option('-f, --flavor <flavor>', ['client', 'gensrc'])
+  .option('-f, --flavor <flavor>', ['client', 'gensrc', 'universal'])
   .option('    --with-localized')
   .help(`
   Usage: cdsc toCsn [options] <files...>
@@ -350,6 +355,7 @@ optionProcessor.command('toCsn')
                                       combination with additional "extend" or "annotate"
                                       statements, but not suitable for consumption by clients or
                                       backends
+                            universal: in development (BETA)
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.

package/lib/render/.eslintrc.json

@@ -7,8 +7,11 @@
     "prefer-template": "error",
     "no-trailing-spaces": "error",
     "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": ["off"],
+    "sonarjs/no-nested-template-literals": "off",
     "template-curly-spacing":["error", "never"],
-    "complexity": ["warn", 30],
+    // Who cares - just very whiny and in the way
+    "complexity": "off",
     "max-len": "off",
     // We should enable this
     "no-shadow": "off"