Fix placeholder limits not working with fallbacks

Author: synzen

services/user-feeds-next/src/articles/formatter/article-formatter.test.ts

@@ -88,6 +88,84 @@ describe("article-formatter", () => {
       );
       assert.strictEqual(result, "Third Value");
     });
+
+    it("applies placeholder limits with fallback syntax - first placeholder used", () => {
+      const result = replaceTemplateString(
+        { summary: "This is a long summary that should be truncated", description: "Description text" },
+        "{{summary||description}}",
+        {
+          supportFallbacks: true,
+          split: {
+            func: (str, opts) => str.substring(0, opts.limit) + (str.length > opts.limit ? (opts.appendString || "") : ""),
+            limits: [
+              { placeholder: "summary", characterCount: 15, appendString: "..." },
+              { placeholder: "description", characterCount: 20, appendString: "..." },
+            ],
+          },
+        }
+      );
+      // Should use summary limit (15) since summary was used
+      assert.ok(result!.startsWith("This is a long "));
+      assert.ok(result!.endsWith("..."));
+      assert.ok(result!.length <= 18); // 15 + 3 for "..."
+    });
+
+    it("applies placeholder limits with fallback syntax - falls back to second placeholder", () => {
+      const result = replaceTemplateString(
+        { description: "This is a long description that should be truncated" },
+        "{{summary||description}}",
+        {
+          supportFallbacks: true,
+          split: {
+            func: (str, opts) => str.substring(0, opts.limit) + (str.length > opts.limit ? (opts.appendString || "") : ""),
+            limits: [
+              { placeholder: "summary", characterCount: 10, appendString: " [sum]" },
+              { placeholder: "description", characterCount: 15, appendString: " [desc]" },
+            ],
+          },
+        }
+      );
+      // Should use description limit (15) since description was used as fallback
+      assert.ok(result!.startsWith("This is a long "));
+      assert.ok(result!.endsWith("[desc]"));
+      assert.ok(result!.length <= 22); // 15 + 7 for " [desc]"
+    });
+
+    it("does not apply placeholder limits when fallback resolves to literal text", () => {
+      const result = replaceTemplateString(
+        {},
+        "{{summary||text::No summary available}}",
+        {
+          supportFallbacks: true,
+          split: {
+            func: (str, opts) => str.substring(0, opts.limit) + (str.length > opts.limit ? (opts.appendString || "") : ""),
+            limits: [
+              { placeholder: "summary", characterCount: 5, appendString: "..." },
+            ],
+          },
+        }
+      );
+      // Literal text should not be truncated
+      assert.strictEqual(result, "No summary available");
+    });
+
+    it("supports limit on full accessor string as fallback", () => {
+      const result = replaceTemplateString(
+        { summary: "This is a long summary text" },
+        "{{summary||description}}",
+        {
+          supportFallbacks: true,
+          split: {
+            func: (str, opts) => str.substring(0, opts.limit) + (str.length > opts.limit ? (opts.appendString || "") : ""),
+            limits: [
+              { placeholder: "summary||description", characterCount: 10, appendString: "..." },
+            ],
+          },
+        }
+      );
+      // Should use the full accessor limit
+      assert.ok(result!.length <= 13); // 10 + 3 for "..."
+    });
   });
 
   describe("applySplit", () => {

services/user-feeds-next/src/articles/formatter/article-formatter.ts

@@ -713,29 +713,36 @@ export function replaceTemplateString(
   while ((result = regex.exec(str)) !== null) {
     const accessor = result[1]!;
     let value = "";
+    let usedPlaceholder: string | null = null;
 
     if (options?.supportFallbacks) {
       const values = accessor.split("||");
       for (const subvalue of values) {
         // Special "text::" prefix for literal fallback text
         if (subvalue.startsWith("text::")) {
           value = subvalue.replace("text::", "");
+          usedPlaceholder = null; // literal text, no placeholder limit applies
           break;
         }
         const valueInObject = object[subvalue];
         if (valueInObject) {
           value = valueInObject;
+          usedPlaceholder = subvalue;
           break;
         }
       }
     } else {
       value = object[accessor] || "";
+      usedPlaceholder = accessor;
     }
 
     // Apply split limits for specific placeholders
+    // Check for limit on: 1) the specific placeholder that provided the value, 2) the full accessor
     if (options?.split?.func && options.split.limits) {
       const limit = options.split.limits.find(
-        (i) => i.placeholder === accessor
+        (i) =>
+          (usedPlaceholder && i.placeholder === usedPlaceholder) ||
+          i.placeholder === accessor
       );
       if (limit) {
         const appendString = replaceTemplateString(object, limit.appendString, {

services/user-feeds-next/test/e2e/discord-payload-placeholder-limits.e2e-spec.ts

@@ -591,4 +591,158 @@ describe("Discord Payload Placeholder Limits (e2e)", { concurrency: true }, () =
       }
     });
   });
+
+  describe("Fallback Syntax with Placeholder Limits", () => {
+    it("applies limit when using fallback syntax and first placeholder has value", async () => {
+      const ctx = createTestContext(stores);
+
+      const eventWithLimits = createEventWithPlaceholderLimits(
+        ctx.testFeedV2Event,
+        [
+          {
+            placeholder: "summary",
+            characterCount: 20,
+            appendString: "...",
+          },
+          {
+            placeholder: "description",
+            characterCount: 30,
+            appendString: "...",
+          },
+        ],
+        {
+          content: "{{summary||description}}",
+        }
+      );
+
+      try {
+        await ctx.seedArticles(eventWithLimits);
+
+        ctx.setFeedResponse(() => ({
+          body: getTestRssFeed(
+            [
+              {
+                guid: "fallback-limit-summary-test",
+                summary:
+                  "This is a long summary that should be truncated to 20 chars",
+                description: "This description should not be used",
+              },
+            ],
+            true
+          ),
+          hash: randomUUID(),
+        }));
+
+        const results = await ctx.handleEvent(eventWithLimits);
+
+        assert.notStrictEqual(results, null);
+
+        const payload = getDiscordPayload(ctx);
+        // Summary limit (20) + append string (3) = 23 max
+        assert.ok(payload.content.length <= 23);
+        assert.ok(payload.content.includes("..."));
+      } finally {
+        ctx.cleanup();
+      }
+    });
+
+    it("applies limit when using fallback syntax and falls back to second placeholder", async () => {
+      const ctx = createTestContext(stores);
+
+      const eventWithLimits = createEventWithPlaceholderLimits(
+        ctx.testFeedV2Event,
+        [
+          {
+            placeholder: "summary",
+            characterCount: 20,
+            appendString: " [sum]",
+          },
+          {
+            placeholder: "description",
+            characterCount: 25,
+            appendString: " [desc]",
+          },
+        ],
+        {
+          content: "{{summary||description}}",
+        }
+      );
+
+      try {
+        await ctx.seedArticles(eventWithLimits);
+
+        ctx.setFeedResponse(() => ({
+          body: getTestRssFeed(
+            [
+              {
+                guid: "fallback-limit-description-test",
+                // No summary - will fall back to description
+                description:
+                  "This is a long description that should be truncated to 25 chars",
+              },
+            ],
+            true
+          ),
+          hash: randomUUID(),
+        }));
+
+        const results = await ctx.handleEvent(eventWithLimits);
+
+        assert.notStrictEqual(results, null);
+
+        const payload = getDiscordPayload(ctx);
+        // Description limit (25) + append string (7) = 32 max
+        assert.ok(payload.content.length <= 32);
+        assert.ok(payload.content.includes("[desc]"));
+        assert.ok(!payload.content.includes("[sum]"));
+      } finally {
+        ctx.cleanup();
+      }
+    });
+
+    it("does not apply limit when fallback resolves to literal text", async () => {
+      const ctx = createTestContext(stores);
+
+      const eventWithLimits = createEventWithPlaceholderLimits(
+        ctx.testFeedV2Event,
+        [
+          {
+            placeholder: "summary",
+            characterCount: 10,
+            appendString: "...",
+          },
+        ],
+        {
+          content: "{{summary||text::No summary available}}",
+        }
+      );
+
+      try {
+        await ctx.seedArticles(eventWithLimits);
+
+        ctx.setFeedResponse(() => ({
+          body: getTestRssFeed(
+            [
+              {
+                guid: "fallback-literal-test",
+                // No summary - will fall back to literal text
+              },
+            ],
+            true
+          ),
+          hash: randomUUID(),
+        }));
+
+        const results = await ctx.handleEvent(eventWithLimits);
+
+        assert.notStrictEqual(results, null);
+
+        const payload = getDiscordPayload(ctx);
+        // Literal text should not be truncated
+        assert.strictEqual(payload.content, "No summary available");
+      } finally {
+        ctx.cleanup();
+      }
+    });
+  });
 });