fix: Preserve camel case i18n tags

CHANGELOG.md

@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Deprecated
 ### Removed
 ### Fixed
+- `@Common.Label` values containing i18n placeholders (e.g. `{i18n>TasksPlural}`) are no longer corrupted by camelCase word-splitting in tag names
 - Entities that are transitively autoexposed and should still be considered readonly, do not generate documentation for write endpoints anymore
 - Implicitly auto-exposed composition targets (annotated `@cds.autoexposed` by the CDS compiler) no longer generate top-level GET paths that CAP would reject with 405
 - OpenAPI compilation is now pure: the input CSN is no longer mutated during compilation

lib/compile/csdl2openapi.js

@@ -90,7 +90,7 @@
  * @param {{ url?: string, servers?: object, odataVersion?: string, scheme?: string, host?: string, basePath?: string, diagram?: boolean, maxLevels?: number, shortActionPaths?: boolean }} options Optional parameters
  * @return {*} OpenAPI description
  */
 module.exports.csdl2openapi = function (
     csdl,
     {
         url: serviceRoot,
@@ -407,9 +407,10 @@
      * @returns {T}
      */
     function normaliseTag(tag) {
-        const normalise = s => s
-            .replaceAll('_', ' ')
-            .replace(/([a-z])([A-Z])/g, '$1 $2');  // "camelCase" to "camel Case"
+        const normalise = s => /{i18n>([^}]+)}/.test(s)
+            ? s
+            : s.replaceAll('_', ' ')
+               .replace(/([a-z])([A-Z])/g, '$1 $2');  // "camelCase" to "camel Case"
         if (typeof tag === 'string') {
             tag = normalise(tag);
         } else {
@@ -475,7 +476,7 @@
      * @param {number} options.level Number of navigation segments so far
      * @param {string} options.navigationPath Path for finding navigation restrictions
      */
     function pathItems({ paths, prefix, prefixParameters, element, root, sourceName, targetName, target, level, navigationPath }) {
         const name = prefix.substring(prefix.lastIndexOf('/') + 1);
         const type = meta.modelElement(element.$Type);
         const pathItem = {};
@@ -753,7 +754,7 @@
      * @param {boolean} options.byKey Read by key
      * @param {array} options.nonExpandable Non-expandable navigation properties
      */
     function operationRead({ pathItem, element, name, sourceName, targetName, target, level, restrictions, byKey, nonExpandable }) {
         const targetRestrictions = target?.[meta.voc.Capabilities.ReadRestrictions];
         const readRestrictions = restrictions.ReadRestrictions || targetRestrictions || {};
         const readByKeyRestrictions = readRestrictions.ReadByKeyRestrictions;
@@ -1223,7 +1224,7 @@
      * @param {*} options.restrictions Navigation property restrictions of navigation segment
      * @param {boolean} [options.byKey=false] Update by key
      */
     function operationUpdate({ pathItem, element, name, sourceName, target, level, restrictions, byKey = false }) {
         const updateRestrictions = restrictions.UpdateRestrictions || target?.[meta.voc.Capabilities.UpdateRestrictions] || {};
         const countRestrictions = target?.[meta.voc.Capabilities.CountRestrictions]?.Countable === false;
         if (updateRestrictions.Updatable !== false && !element[meta.voc.Core.Immutable]) {
@@ -1314,7 +1315,7 @@
      */
     function pathItemsForMediaStream({ paths, prefix, prefixParameters, type, name, sourceName }) {
         if (type.$HasStream) {
             const mediaTypes = type[meta.voc.Core.AcceptableMediaTypes]?.map(t => t['$EnumMember'] ?? t) ?? [];
             const contentTypes = mediaTypes.length > 0 ? mediaTypes : ['*/*'];
             const mediaContent = Object.fromEntries(contentTypes.map(ct => [ct, { schema: { type: 'string', format: 'binary' } }]));
             const lname = splitName(name);
@@ -1644,7 +1645,7 @@
      * @param {string} options.sourceName Name of path source
      * @param {*} [options.actionImport={}] Action import
      */
     function pathItemAction({ paths, prefix, prefixParameters, actionName, overload, sourceName, actionImport = {} }) {
         const name = actionName.indexOf('.') === -1 ? actionName : nameParts(actionName).name;
         const pathItem = {
             post: {
@@ -1734,7 +1735,7 @@
      * @param {string} options.sourceName Name of path source
      * @param {*} [options.functionImport={}] Function Import
      */
     function pathItemFunction({ paths, prefix, prefixParameters, functionName, overload, sourceName, functionImport = {} }) {
         const name = functionName.indexOf('.') === -1 ? functionName : nameParts(functionName).name;
         let parameters = overload.$Parameter || [];
         if (overload.$IsBound) parameters = parameters.slice(1);
@@ -1743,7 +1744,7 @@
 
         const implicitAliases = csdl.$Version > '4.0' || parameters.some(p => p[meta.voc.Core.OptionalParameter]);
 
         parameters.forEach(p => {
             const description = getDescriptionWithFallback(p);
             /** @type {Parameter} */
             const param = {
@@ -2123,7 +2124,7 @@
      * @param {string} options.suffix Suffix for read/create/update
      * @return {*} Map of Schemas Objects
      */
     function schemasForStructuredType({ schemas, qualifier, name, type, suffix }) {
         const schemaName = `${qualifier}.${name}${suffix}`;
         const baseName = `${qualifier}.${name}`;
         const isKey = keyMap(type);
@@ -2139,7 +2140,7 @@
         const properties = propertiesOfStructuredType(type);
         const expandRestrictions = type[meta.voc.Capabilities.ExpandRestrictions] ?? {};
         const nonExpandableProperties = expandRestrictions.NonExpandableProperties ?? [];
         Object.keys(properties).forEach(iName => {
             if (nonExpandableProperties.includes(iName)) {
                 return;
             }

test/lib/compile/csdl2openapi.test.js

@@ -2725,6 +2725,141 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
       "MaxLength"
     );
   });
+
+  it("preserves i18n placeholders in tag names without splitting camelCase", () => {
+    const csdl = {
+      $Version: "4.01",
+      $Reference: {
+        dummy: {
+          $Include: [{ $Namespace: "com.sap.vocabularies.Common.v1", $Alias: "Common" }],
+        },
+      },
+      $EntityContainer: "TestService.Container",
+      TestService: {
+        Container: {
+          $Kind: "EntityContainer",
+          Tasks: { $Collection: true, $Type: "TestService.Tasks" },
+        },
+        Tasks: {
+          $Kind: "EntityType",
+          $Key: ["ID"],
+          ID: { $Type: "Edm.Guid" },
+        },
+        $Annotations: {
+          "TestService.Tasks": { "@Common.Label": "{i18n>TasksPlural}" },
+        },
+      },
+    };
+    const openapi = lib.csdl2openapi(csdl, {});
+    assert.strictEqual(
+      openapi.tags[0].name,
+      "{i18n>TasksPlural}",
+      "i18n placeholder must not be split by camelCase normalisation"
+    );
+    const getOp = openapi.paths["/Tasks"]?.get;
+    assert.ok(getOp, "GET /Tasks operation must exist");
+    assert.strictEqual(
+      getOp.tags[0],
+      "{i18n>TasksPlural}",
+      "operation-level tag must also preserve the placeholder"
+    );
+  });
+
+  it("still splits plain camelCase label into words", () => {
+    const csdl = {
+      $Version: "4.01",
+      $Reference: {
+        dummy: {
+          $Include: [{ $Namespace: "com.sap.vocabularies.Common.v1", $Alias: "Common" }],
+        },
+      },
+      $EntityContainer: "TestService.Container",
+      TestService: {
+        Container: {
+          $Kind: "EntityContainer",
+          Tasks: { $Collection: true, $Type: "TestService.Tasks" },
+        },
+        Tasks: {
+          $Kind: "EntityType",
+          $Key: ["ID"],
+          ID: { $Type: "Edm.Guid" },
+        },
+        $Annotations: {
+          "TestService.Tasks": { "@Common.Label": "TasksPlural" },
+        },
+      },
+    };
+    const openapi = lib.csdl2openapi(csdl, {});
+    assert.strictEqual(
+      openapi.tags[0].name,
+      "Tasks Plural",
+      "plain camelCase label must still be split into words"
+    );
+  });
+
+  it("preserves i18n placeholder embedded in a mixed label without splitting camelCase", () => {
+    const csdl = {
+      $Version: "4.01",
+      $Reference: {
+        dummy: {
+          $Include: [{ $Namespace: "com.sap.vocabularies.Common.v1", $Alias: "Common" }],
+        },
+      },
+      $EntityContainer: "TestService.Container",
+      TestService: {
+        Container: {
+          $Kind: "EntityContainer",
+          Tasks: { $Collection: true, $Type: "TestService.Tasks" },
+        },
+        Tasks: {
+          $Kind: "EntityType",
+          $Key: ["ID"],
+          ID: { $Type: "Edm.Guid" },
+        },
+        $Annotations: {
+          "TestService.Tasks": { "@Common.Label": "MyService {i18n>TasksLabel}" },
+        },
+      },
+    };
+    const openapi = lib.csdl2openapi(csdl, {});
+    assert.strictEqual(
+      openapi.tags[0].name,
+      "MyService {i18n>TasksLabel}",
+      "mixed label with i18n placeholder must not be split"
+    );
+  });
+
+  it("preserves multiple i18n placeholders in a label without splitting camelCase", () => {
+    const csdl = {
+      $Version: "4.01",
+      $Reference: {
+        dummy: {
+          $Include: [{ $Namespace: "com.sap.vocabularies.Common.v1", $Alias: "Common" }],
+        },
+      },
+      $EntityContainer: "TestService.Container",
+      TestService: {
+        Container: {
+          $Kind: "EntityContainer",
+          Tasks: { $Collection: true, $Type: "TestService.Tasks" },
+        },
+        Tasks: {
+          $Kind: "EntityType",
+          $Key: ["ID"],
+          ID: { $Type: "Edm.Guid" },
+        },
+        $Annotations: {
+          "TestService.Tasks": { "@Common.Label": "{i18n>FirstLabel} and {i18n>SecondLabel}" },
+        },
+      },
+    };
+    const openapi = lib.csdl2openapi(csdl, {});
+    assert.strictEqual(
+      openapi.tags[0].name,
+      "{i18n>FirstLabel} and {i18n>SecondLabel}",
+      "label with multiple i18n placeholders must not be split"
+    );
+  });
 });
 
 describe("Bound action path naming", () => {