@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/forOdataNew.js

@@ -4,10 +4,10 @@ const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
 const { getUtils,
-        cloneCsn,
+        cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
-        forEachRef,
+        applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
         isAspect,
@@ -16,15 +16,14 @@ const { getUtils,
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { isArtifactInSomeService, getServiceOfArtifact, isLocalizedArtifactInService } = require('./odata/utils');
-const ReferenceFlattener = require('./odata/referenceFlattener');
-const { flattenCSN } = require('./odata/structureFlattener');
-const generateForeignKeys = require('./odata/generateForeignKeyElements');
-const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
+const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
-const { attachPath } = require('./odata/attachPath');
-const enrichUniversalCsn = require('./universalCsnEnricher');
+const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
+const flattening = require('./db/flattening');
+const associations = require('./db/associations')
+const expansion = require('./db/expansion');
+const generateDrafts = require('./draft/odata');
 
 const { addLocalizationViews } = require('./localized');
 
@@ -73,10 +72,10 @@ module.exports = { transform4odataWithCsn };
 function transform4odataWithCsn(inputModel, options) {
   timetrace.start('OData transformation');
   // copy the model as we don't want to change the input model
-  let csn = cloneCsn(inputModel, options);
+  let csn = cloneCsnNonDict(inputModel, options);
 
-  const { error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
-  throwWithError();
+  const { message, error, warning, info, throwWithAnyError } = makeMessageFunction(csn, options, 'for.odata');
+  throwWithAnyError();
 
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
@@ -84,25 +83,18 @@ function transform4odataWithCsn(inputModel, options) {
   const transformers = transformUtils.getTransformers(csn, options, '_');
   const {
     addDefaultTypeFacets,
-    createForeignKeyElement,
-    createAndAddDraftAdminDataProjection, createScalarElement,
-    createAssociationElement, createAssociationPathComparison,
-    addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
+    recurseElements, setAnnotation, renameAnnotation,
     expandStructsInExpression
   } = transformers;
 
   const csnUtils = getUtils(csn);
   const {
     getCsnDef,
-    getFinalType,
     getServiceName,
-    hasAnnotationValue,
     isAssocOrComposition,
     isAssociation,
-    isStructured,
     inspectRef,
     artifactRef,
     effectiveType,
@@ -132,13 +124,13 @@ function transform4odataWithCsn(inputModel, options) {
 
   addLocalizationViews(csn, options, acceptLocalizedView);
 
-  validate.forOdata(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
+  const cleanup = validate.forOdata(csn, {
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
   });
 
 
   // Throw exception in case of errors
-  throwWithError();
+  throwWithAnyError();
 
   // Semantic checks before flattening regarding temporal data
   // TODO: Move in the validator
@@ -160,35 +152,38 @@ function transform4odataWithCsn(inputModel, options) {
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
-  // If errors are detected, throwWithError() will return from further processing
+  // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
-  // handles reference flattening
-  let referenceFlattener = new ReferenceFlattener();
-  referenceFlattener.resolveAllReferences(csn, inspectRef, isStructured);
-  attachPath(csn);
-
-  referenceFlattener.applyAliasesInOnCond(csn, inspectRef);
-
   if (!structuredOData) {
-    // flatten structures
-    // @ts-ignore
-    flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember);
-    // flatten references
-    referenceFlattener.flattenAllReferences(csn);
+    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, { skipArtifact: isExternalServiceMember });
+    const resolved = new WeakMap();
+    // No refs with struct-steps exist anymore
+    flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
+    // No type references exist anymore
+    // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
+    // OData doesn't resolve type chains after the first 'items'
+    flattening.resolveTypeReferences(csn, options, resolved, '_',
+      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
+    // No structured elements exists anymore
+    flattening.flattenElements(csn, options, '_', error,
+      { skip: ['action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember,
+        skipStandard: { items: true },  // don't drill further into .items
+        skipDict: { actions: true } }); // don't drill further into .actions -> bound actions, action-artifacts are handled by skip
   }
 
-  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
-  throwWithError();
+  // TODO: add the generated foreign keys to the columns when we are in a view
+  // see db/views.js::addForeignKeysToColumns
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, { skipArtifact: isExternalServiceMember });
 
-  // Process associations
-  // 1. In case we generate flat mode, expand the structured foreign keys.
-  // This logic rewrites the 'ref' for such keys with the corresponding flattened
-  // elements.
-  if (!structuredOData)
-    expandStructKeysInAssociations(csn, referenceFlattener, csnUtils, isExternalServiceMember);
-  // 2. generate foreign keys for managed associations
-  generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
+  // Allow using managed associations as steps in on-conditions to access their fks
+  // To be done after handleManagedAssociationsAndCreateForeignKeys,
+  // since then the foreign keys of the managed assocs are part of the elements
+  if(!structuredOData)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, '_'));
+
+  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
+  throwWithAnyError();
 
   // Apply default type facets as set by options
   // Flatten on-conditions in unmanaged associations
@@ -209,37 +204,26 @@ function transform4odataWithCsn(inputModel, options) {
   //        - structured types must not contain associations for OData V2
   // - Element must not be an 'array of' for OData V2 TODO: move to the validator
   // - Perform checks for exposed non-abstract entities and views - check media type and key-ness
-  let visitedArtifacts = Object.create(null);
-  forEachDefinition(csn, (def, defName) => {
-    if (def.kind === 'entity' || def.kind === 'view') {
-      // Generate artificial draft fields if requested
-      if (def['@odata.draft.enabled']) {
-        // Ignore if not part of a service
-        if (isArtifactInSomeService(defName, services)) {
-          generateDraftForOdata(def, defName, def, visitedArtifacts);
-        }
-      }
-    }
-    visitedArtifacts[defName] = true;
-  }, { skipArtifact: isExternalServiceMember });
+  generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
+  const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
     renameShorthandAnnotations(def);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
-    if (options.toOdata.names && !['service', 'context', 'namespace', 'annotation', 'action', 'function'].includes(def.kind))
+    if (options.toOdata.names && !(def.kind in skipPersNameKinds))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
 
-    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
-      if (options.toOdata.names && typeof member === 'object' && !['action', 'function'].includes(member.kind) && propertyName !== 'enum' && (!member.virtual || def.query)) {
+      if (options.toOdata.names && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(referenceFlattener.getElementNameWithDots(path) || memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.toOdata.names);
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -269,9 +253,9 @@ function transform4odataWithCsn(inputModel, options) {
   }, { skipArtifact: isExternalServiceMember })
 
   // Throw exception in case of errors
-  throwWithError();
-
-  if (options.testMode) csn = cloneCsn(csn, options);   // sort, keep hidden properties
+  throwWithAnyError();
+  cleanup();
+  if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
   timetrace.stop();
   return csn;
 
@@ -342,7 +326,7 @@ function transform4odataWithCsn(inputModel, options) {
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
         if (name === '@readonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -352,7 +336,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
         // @insertonly is effective on entities/queries only
         else if (name === '@insertonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -423,151 +407,14 @@ function transform4odataWithCsn(inputModel, options) {
     // removes leading $self in on-conditions's references
     function removeLeadingDollarSelfInOnCondition(assoc) {
       if (!assoc.on) return; // nothing to do
-      forEachRef(assoc, (ref, node) => {
-        // remove leading $self when at the begining of a ref
-        if (ref.length > 1 && ref[0] === '$self')
-          node.ref.splice(0, 1);
-      });
-    }
-  }
-
-  // Generate all that is required in ODATA for draft enablement of 'artifact' into the artifact,
-  // into its transitively reachable composition targets, and into the model.
-  // 'rootArtifact' is the root artifact where composition traversal started.
-
-  // Constraints
-  // Draft Root: Exactly one PK of type UUID
-  // Draft Node: One PK of type UUID + 0..1 PK of another type
-  // Draft Node: Must not be reachable from multiple draft roots
-  function generateDraftForOdata(artifact, artifactName, rootArtifact, visitedArtifacts) {
-    // Sanity check
-    // @ts-ignore
-    if (!isArtifactInSomeService(artifactName, services)) {
-      throw new Error('Expecting artifact to be part of a service: ' + JSON.stringify(artifact));
-    }
-    // Nothing to do if already draft-enabled (composition traversal may have circles)
-    if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction'])
-      && artifact.actions && artifact.actions.draftPrepare) {
-      return;
-    }
-
-    // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    // @ts-ignore
-    let draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
-    let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
-    if (!draftAdminDataProjection) {
-      // @ts-ignore
-      draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
-    }
-    // Report an error if it is not an entity or not what we expect
-    if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements['DraftUUID']) {
-      error(null, ['definitions', draftAdminDataProjectionName], { name: draftAdminDataProjectionName },
-        `Generated entity $(NAME) conflicts with existing artifact`);
-    }
-    // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
-    if (artifact == rootArtifact) {
-      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, ['definitions', draftAdminDataProjectionName]);
-      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, ['definitions', draftAdminDataProjectionName]);
-      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
-    } else {
-      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
-    }
-
-    artifact.elements && Object.values(artifact.elements).forEach( elem => {
-      // Make all non-key elements nullable
-      if (elem.notNull && elem.key !== true) {
-        delete elem.notNull;
-      }
-    });
-    // Generate the additional elements into the draft-enabled artifact
-
-    // key IsActiveEntity : Boolean default true
-    let isActiveEntity = createScalarElement('IsActiveEntity', 'cds.Boolean', true, true, false);
-    isActiveEntity.IsActiveEntity['@UI.Hidden'] = true;
-    addElement(isActiveEntity, artifact, artifactName);
-
-    // HasActiveEntity : Boolean default false
-    let hasActiveEntity = createScalarElement('HasActiveEntity', 'cds.Boolean', false, false, true);
-    hasActiveEntity.HasActiveEntity['@UI.Hidden'] = true;
-    addElement(hasActiveEntity, artifact, artifactName);
-
-    // HasDraftEntity : Boolean default false;
-    let hasDraftEntity = createScalarElement('HasDraftEntity', 'cds.Boolean', false, false, true);
-    hasDraftEntity.HasDraftEntity['@UI.Hidden'] = true;
-    addElement(hasDraftEntity, artifact, artifactName);
-
-    // @odata.contained: true
-    // DraftAdministrativeData : Association to one DraftAdministrativeData;
-    let draftAdministrativeData = createAssociationElement('DraftAdministrativeData', draftAdminDataProjectionName, true);
-    draftAdministrativeData.DraftAdministrativeData.cardinality = { max: 1, };
-    draftAdministrativeData.DraftAdministrativeData['@odata.contained'] = true;
-    draftAdministrativeData.DraftAdministrativeData['@UI.Hidden'] = true;
-    addElement(draftAdministrativeData, artifact, artifactName);
-
-    // Note that we need to do the ODATA transformation steps for managed associations
-    // (foreign key field generation, generatedFieldName) by hand, because the corresponding
-    // transformation steps have already been done on all artifacts when we come here)
-    let uuidDraftKey = draftAdministrativeData.DraftAdministrativeData.keys.filter(key => key.ref && key.ref.length === 1 && key.ref[0] === 'DraftUUID');
-    if (uuidDraftKey && uuidDraftKey[0]) {
-      uuidDraftKey = uuidDraftKey[0]; // filter returns an array, but it has only one element
-      let path = ['definitions', artifactName, 'elements', 'DraftAdministrativeData', 'keys', 0];
-      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', uuidDraftKey, artifact, artifactName, path);
-    }
-    // SiblingEntity : Association to one <artifact> on (... IsActiveEntity unequal, all other key fields equal ...)
-    let siblingEntity = createAssociationElement('SiblingEntity', artifactName, false);
-    siblingEntity.SiblingEntity.cardinality = { max: 1 };
-    addElement(siblingEntity, artifact, artifactName);
-    // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
-    siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
-
-    // Iterate elements
-    artifact.elements && Object.entries(artifact.elements).forEach( ([elemName, elem]) => {
-      if (elemName !== 'IsActiveEntity' && elem.key) {
-        // Amend the ON-condition above:
-        // ... and SiblingEntity.<keyfield> = <keyfield> ... (for all key fields except 'IsActiveEntity')
-        let cond = createAssociationPathComparison('SiblingEntity', elemName, '=', elemName);
-        cond.push('and');
-        cond.push(...siblingEntity.SiblingEntity.on);
-        siblingEntity.SiblingEntity.on = cond;
-      }
-
-      // Draft-enable the targets of composition elements (draft nodes), too
-      // TODO rewrite
-      if (elem.target && elem.type && getFinalType(elem.type) === 'cds.Composition') {
-        let draftNode = csn.definitions[elem.target];
-
-        // Ignore if that is our own draft root
-        if (draftNode != rootArtifact) {
-          // Report error when the draft node has @odata.draft.enabled itself
-          if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
-            error(null, ['definitions', artifactName, 'elements', elemName], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
-          }
-          // Ignore composition if not part of a service or explicitly draft disabled
-          else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
-            return;
-          }
-          else {
-            // Generate draft stuff into the target
-            generateDraftForOdata(draftNode, elem.target, rootArtifact, visitedArtifacts);
-          }
+      // TODO: Shouldn't this only run on the on-condition and not the whole assoc-node?
+      applyTransformationsOnNonDictionary({ assoc }, 'assoc', {
+        ref: (node, prop, ref) => {
+          // remove leading $self when at the begining of a ref
+          if (ref.length > 1 && ref[0] === '$self')
+            node.ref.splice(0, 1);
         }
-      }
-    });
-
-    // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
-
-    // action draftPrepare (SideEffectsQualifier: String) return <artifact>;
-    let draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
-    assignAction(draftPrepare, artifact);
-
-    if (artifact == rootArtifact) {
-      // action draftActivate() return <artifact>;
-      let draftActivate = createAction('draftActivate', artifactName);
-      assignAction(draftActivate, artifact);
-
-      // action draftEdit (PreserveChanges: Boolean) return <artifact>;
-      let draftEdit = createAction('draftEdit', artifactName, 'PreserveChanges', 'cds.Boolean');
-      assignAction(draftEdit, artifact);
+      });
     }
   }
 

package/lib/transform/localized.js

@@ -3,10 +3,10 @@
 const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
-const { cloneCsnDictionary } = require('../model/csnUtils');
+const { cloneCsnDictionary, applyDefinitionAnnotationsFromExtensions} = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
-  cloneCsn,
+  cloneCsnNonDict,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
@@ -48,7 +48,7 @@ const _targetFor = Symbol('_targetFor');
  * We have three kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements: as projection on the original (created in definer.js)
+ *     elements: as projection on the original (created in extend.js)
  *  2. for table entities with associations to entities which have a localized
  *     convenience views or redirections thereon: as projection on the original
  *  3. for view entities with associations to entities which have a localized
@@ -74,11 +74,10 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasErrors(options.messages))
     return csn;
 
-  if (hasExistingLocalizationViews(csn, options))
+  const messageFunctions = makeMessageFunction(csn, options);
+  if (hasExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
-  const { info } = makeMessageFunction(csn, options);
-
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
 
@@ -87,6 +86,12 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
   forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
+  // In case that the user tried to annotate `localized.*` artifacts, apply them.
+  applyDefinitionAnnotationsFromExtensions(csn, {
+    overwrite: true,
+    filter: (name) => name.startsWith('localized.')
+  });
+
   sortCsnDefinitionsForTests(csn, options);
   return csn;
 
@@ -102,7 +107,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
         return;
 
       if (isInLocalizedNamespace(artName))
-        // We already issued a warning for it in warnAboutExistingLocalizationViews()
+        // We already issued a warning for it in hasExistingLocalizationViews()
         return;
 
       const localized = getLocalizedTextElements( artName );
@@ -127,7 +132,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
     if (csn.definitions[viewName]) {
       // Already exists, skip creation.
-      info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
+      messageFunctions.info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
       return;
     }
 
@@ -142,9 +147,8 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
+    copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
-
-    copyPersistenceAnnotations(csn.definitions[viewName], art);
   }
 
   /**
@@ -246,9 +250,9 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     };
 
     if (view.query)
-      convenienceView.query = cloneCsn(view.query, options);
+      convenienceView.query = cloneCsnNonDict(view.query, options);
     else if (view.projection)
-      convenienceView.projection = cloneCsn(view.projection, options);
+      convenienceView.projection = cloneCsnNonDict(view.projection, options);
 
     convenienceView.elements = cloneCsnDictionary(view.elements, options);
     convenienceView[_isViewForView] = true;
@@ -339,7 +343,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
 
-      // TODO: Already warned about in definer.js
+      // TODO: Already warned about in extend.js
       // if (elem.key && isLocalized)
       //   warning( 'localized-key', path, {}, 'Keyword "localized" is ignored for primary keys' );
     }, artPath);
@@ -349,7 +353,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       return null;
 
     if (!isEntityPreprocessed( art )) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements' );
       return null;
     }
@@ -358,13 +362,13 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     const textsEntity = csn.definitions[textsName];
 
     if (!textsEntity) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
 
     if (!isValidTextsEntity( textsEntity )) {
-      info( null, [ 'definitions', textsName ], { name: artName },
+      messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
@@ -550,7 +554,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     if (!obj || typeof obj !== 'object' || Array.isArray(obj))
       return;
 
-    for (const prop of [ 'ref', 'target', 'on' ]) {
+    for (const prop of [ 'ref', 'target' ]) {
       const val = obj[prop];
       if (prop === 'ref') {
         rewriteRefToLocalized(obj);
@@ -685,18 +689,32 @@ function copyPersistenceAnnotations(target, source) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
-function hasExistingLocalizationViews(csn, options) {
+function hasExistingLocalizationViews(csn, options, messageFunctions) {
   if (!csn || !csn.definitions)
     return false;
-  const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
-  if (firstLocalizedView) {
-    const { info } = makeMessageFunction(csn, options);
-    info( null, [ 'definitions', firstLocalizedView ], {},
-          'Input CSN already contains expansions for localized data' );
-    return true;
+
+  let hasExistingViews = false;
+  let hasNonViews = false;
+
+  for (const name in csn.definitions) {
+    const art = csn.definitions[name];
+    if (isInLocalizedNamespace(name) || name === 'localized') {
+      if (!art.query && !art.projection) {
+        if (!name.endsWith('.texts')) {
+          hasNonViews = true;
+          messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
+            'The namespace "localized" is reserved for localization views');
+        }
+      } else if (!hasExistingViews) {
+        hasExistingViews = true;
+        messageFunctions.info( null, [ 'definitions', name ], {},
+          'Input CSN already contains localization views, no further ones will be created' );
+      }
+    }
   }
-  return false;
+  return hasExistingViews || hasNonViews;
 }
 
 /**
@@ -728,9 +746,10 @@ function isEntityPreprocessed(entity) {
 
 /**
  * @param {string} name
+ * @returns {boolean}
  */
 function isInLocalizedNamespace(name) {
-  return name.startsWith('localized.');
+  return name === 'localized' || name.startsWith('localized.');
 }
 
 /**
@@ -738,6 +757,7 @@ function isInLocalizedNamespace(name) {
  *
  * @param {CSN.Model} csn
  * @param {string} artifactName
+ * @returns {boolean}
  */
 function hasLocalizedConvenienceView(csn, artifactName) {
   return !isInLocalizedNamespace(artifactName) && !!csn.definitions[`localized.${ artifactName }`];