Merge branch 'release' into ww-mongodb-operator-helm

Author: subrata71

Dockerfile

@@ -12,6 +12,9 @@ ENV APPSMITH_SEGMENT_CE_KEY=${APPSMITH_SEGMENT_CE_KEY}
 ARG APPSMITH_BETTERBUGS_API_KEY
 ENV APPSMITH_BETTERBUGS_API_KEY=${APPSMITH_BETTERBUGS_API_KEY}
 
+ARG APPSMITH_PYLON_APP_ID
+ENV APPSMITH_PYLON_APP_ID=${APPSMITH_PYLON_APP_ID}
+
 COPY deploy/docker/fs /
 
 RUN <<END

app/client/package.json

@@ -448,6 +448,7 @@
     "brace-expansion": "1.1.12",
     "form-data": "4.0.4",
     "fast-xml-parser": "4.5.4",
-    "handlebars": "4.7.9"
+    "handlebars": "4.7.9",
+    "protobufjs": "^7.5.5"
   }
 }

app/client/yarn.lock

@@ -29029,9 +29029,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"protobufjs@npm:^7.3.0":
-  version: 7.3.2
-  resolution: "protobufjs@npm:7.3.2"
+"protobufjs@npm:^7.5.5":
+  version: 7.5.5
+  resolution: "protobufjs@npm:7.5.5"
   dependencies:
     "@protobufjs/aspromise": ^1.1.2
     "@protobufjs/base64": ^1.1.2
@@ -29045,7 +29045,7 @@ __metadata:
     "@protobufjs/utf8": ^1.1.0
     "@types/node": ">=13.7.0"
     long: ^5.0.0
-  checksum: cfb2a744787f26ee7c82f3e7c4b72cfc000e9bb4c07828ed78eb414db0ea97a340c0cc3264d0e88606592f847b12c0351411f10e9af255b7ba864eec44d7705f
+  checksum: e316eb0df33a64398ce32056de37435d8ea7ef3e06dff32cda2a7156431c029fe2c120e390b7ff066de7632e996d6d5d0540fb606fef223a8480dff25bee6123
   languageName: node
   linkType: hard
 

app/server/appsmith-interfaces/src/main/java/com/appsmith/external/helpers/MustacheHelper.java

@@ -5,7 +5,6 @@
 import com.appsmith.external.models.EntityReferenceType;
 import com.appsmith.external.models.MustacheBindingToken;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.text.StringEscapeUtils;
 import org.springframework.beans.BeanWrapper;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.PropertyAccessorFactory;
@@ -348,23 +347,32 @@ public static String render(String template, Map<String, String> keyValueMap) {
                 if (!keyValueMap.containsKey(tokenSubstring)) {
                     rendered.append(token.getValue());
                 } else if (bindingValue != null) {
-                    // If the binding value is not null, then append the binding value to the rendered string.
-                    // We are using the token.getValue() here to get the original value of the binding.
-                    // This is because we want to preserve the original formatting of the binding.
-                    // For example, if the binding is {{Input.text}}, we want to preserve the {{}} around it.
-                    rendered.append(bindingValue);
+                    // Handle &quot; and &#34; (HTML-encoded double quotes) inside the binding
+                    // VALUE only, converting them to escaped double quotes (\") so interpolating
+                    // the value into a JSON template keeps the JSON valid.
+                    //
+                    // Scoping to the binding value is deliberate: template literals and
+                    // pass-through content (e.g., binary uploads) must never be mutated by this
+                    // JSON-validity escape. Historically the replacement ran on the fully
+                    // assembled string and corrupted binary data that happened to contain these
+                    // byte sequences. See: https://linear.app/appsmith/issue/V2-3662
+                    rendered.append(escapeHtmlDoubleQuoteEntities(bindingValue));
                 }
             } else {
                 rendered.append(token.getValue());
             }
         }
-        /**
-         * ReplaceAll is used to escape the double quotes symbol with \" so that
-         * JSON remains valid.
-         * &quot; and &#34; both are HTML reserved characters for double quotes (")
-         */
-        return StringEscapeUtils.unescapeHtml4(
-                rendered.toString().replaceAll("&quot;", "\\\\&quot;").replaceAll("&#34;", "\\\\&#34;"));
+        return rendered.toString();
+    }
+
+    private static String escapeHtmlDoubleQuoteEntities(String value) {
+        if (value == null || value.isEmpty()) {
+            return value;
+        }
+        if (value.indexOf('&') < 0) {
+            return value;
+        }
+        return value.replace("&quot;", "\\\"").replace("&#34;", "\\\"");
     }
 
     /**

app/server/appsmith-interfaces/src/main/java/com/appsmith/external/helpers/restApiUtils/helpers/DataUtils.java

@@ -305,11 +305,12 @@ private void populateFileTypeBodyBuilder(
 
         final String fileValue = (String) property.getValue();
         final String key = property.getKey();
+        // Normalize once: routing decisions must be structural, not substring-based on raw input.
+        // Leading whitespace previously misrouted valid JSON payloads to the base64 path. See V2-3662.
+        final String normalized = fileValue == null ? "" : fileValue.trim();
 
-        if (fileValue.contains(BASE64_DELIMITER)) {
-            processBase64Data(fileValue, key, bodyBuilder, outputMessage);
-        } else {
-            List<MultipartFormDataDTO> multipartFormDataDTOs = parseMultipartData(fileValue);
+        if (normalized.startsWith("{") || normalized.startsWith("[")) {
+            List<MultipartFormDataDTO> multipartFormDataDTOs = parseMultipartData(normalized);
 
             for (MultipartFormDataDTO dto : multipartFormDataDTOs) {
                 String dataString = String.valueOf(dto.getData());
@@ -319,6 +320,11 @@ private void populateFileTypeBodyBuilder(
                     processRegularData(dataString, key, bodyBuilder, outputMessage, dto.getName(), dto.getType());
                 }
             }
+        } else if (normalized.contains(BASE64_DELIMITER)) {
+            processBase64Data(normalized, key, bodyBuilder, outputMessage);
+        } else {
+            // Fall back to existing behavior for non-JSON, non-base64 strings (error thrown downstream).
+            parseMultipartData(normalized);
         }
     }
 
@@ -394,12 +400,15 @@ private void addPartToBody(
         bodyBuilder.asyncPart(key, data, DataBuffer.class).filename(filename).contentType(MediaType.valueOf(mimeType));
     }
 
-    // Parse JSON multipart data
+    // Parse JSON multipart data. Trims input so leading whitespace does not cause
+    // a valid JSON payload to be rejected as invalid multipart data. Consistent with
+    // objectFromJson() in this class which trims before type detection.
     private List<MultipartFormDataDTO> parseMultipartData(String fileValue) throws IOException {
-        if (fileValue.startsWith("{")) {
-            return Collections.singletonList(objectMapper.readValue(fileValue, MultipartFormDataDTO.class));
-        } else if (fileValue.startsWith("[")) {
-            return Arrays.asList(objectMapper.readValue(fileValue, MultipartFormDataDTO[].class));
+        final String trimmed = fileValue == null ? "" : fileValue.trim();
+        if (trimmed.startsWith("{")) {
+            return Collections.singletonList(objectMapper.readValue(trimmed, MultipartFormDataDTO.class));
+        } else if (trimmed.startsWith("[")) {
+            return Arrays.asList(objectMapper.readValue(trimmed, MultipartFormDataDTO[].class));
         } else {
             throw new AppsmithPluginException(
                     AppsmithPluginError.PLUGIN_DATASOURCE_ARGUMENT_ERROR, ERROR_INVALID_MULTIPART_DATA);

app/server/appsmith-interfaces/src/test/java/com/appsmith/external/helpers/DataUtilsTest.java

@@ -309,4 +309,95 @@ public void testParseMultipartArrayDataWorks() {
                 .expectComplete()
                 .verify();
     }
+
+    @Test
+    public void testParseMultipartFileData_withBase64FileArray_returnsExpectedBody() {
+        List<Property> properties = new ArrayList<>();
+        String base64DataUrl = "data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago=";
+        final Property p1 = new Property(
+                "fileField",
+                "[{\"name\": \"test.pdf\", \"type\": \"application/pdf\", \"data\": \"" + base64DataUrl + "\"}]");
+        p1.setType("file");
+        properties.add(p1);
+
+        final BodyInserter<Object, MockClientHttpRequest> bodyInserter =
+                (BodyInserter<Object, MockClientHttpRequest>) dataUtils.parseMultipartFileData(properties);
+        MockClientHttpRequest request = new MockClientHttpRequest(HttpMethod.POST, URI.create("https://example.com"));
+
+        Mono<Void> result = bodyInserter.insert(request, this.context);
+        StepVerifier.create(result).expectComplete().verify();
+        StepVerifier.create(DataBufferUtils.join(request.getBody()))
+                .consumeNextWith(dataBuffer -> {
+                    byte[] resultBytes = new byte[dataBuffer.readableByteCount()];
+                    dataBuffer.read(resultBytes);
+                    DataBufferUtils.release(dataBuffer);
+                    String content = new String(resultBytes, StandardCharsets.UTF_8);
+                    assertTrue(content.contains(
+                            "Content-Disposition: form-data; name=\"fileField\"; filename=\"test.pdf\""));
+                    assertTrue(content.contains("Content-Type: application/pdf"));
+                })
+                .expectComplete()
+                .verify();
+    }
+
+    @Test
+    public void testParseMultipartFileData_withBinaryFileContainingHtmlEntityBytes_succeeds() {
+        List<Property> properties = new ArrayList<>();
+        final Property p1 = new Property(
+                "fileField",
+                "[{\"name\": \"test.pdf\", \"type\": \"application/pdf\", "
+                        + "\"data\": \"binary-prefix\u0026#xA;binary-suffix\"}]");
+        p1.setType("file");
+        properties.add(p1);
+
+        final BodyInserter<Object, MockClientHttpRequest> bodyInserter =
+                (BodyInserter<Object, MockClientHttpRequest>) dataUtils.parseMultipartFileData(properties);
+        MockClientHttpRequest request = new MockClientHttpRequest(HttpMethod.POST, URI.create("https://example.com"));
+
+        Mono<Void> result = bodyInserter.insert(request, this.context);
+        StepVerifier.create(result).expectComplete().verify();
+        StepVerifier.create(DataBufferUtils.join(request.getBody()))
+                .consumeNextWith(dataBuffer -> {
+                    byte[] resultBytes = new byte[dataBuffer.readableByteCount()];
+                    dataBuffer.read(resultBytes);
+                    DataBufferUtils.release(dataBuffer);
+                    String content = new String(resultBytes, StandardCharsets.UTF_8);
+                    assertTrue(content.contains(
+                            "Content-Disposition: form-data; name=\"fileField\"; filename=\"test.pdf\""));
+                    assertTrue(content.contains("Content-Type: application/pdf"));
+                    assertTrue(content.contains("&#xA;"));
+                })
+                .expectComplete()
+                .verify();
+    }
+
+    @Test
+    public void testParseMultipartFileData_withLeadingWhitespaceJsonArray_routesAsMultipart() {
+        List<Property> properties = new ArrayList<>();
+        String base64DataUrl = "data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago=";
+        final Property p1 = new Property(
+                "fileField",
+                "   \n[{\"name\": \"test.pdf\", \"type\": \"application/pdf\", \"data\": \"" + base64DataUrl + "\"}]");
+        p1.setType("file");
+        properties.add(p1);
+
+        final BodyInserter<Object, MockClientHttpRequest> bodyInserter =
+                (BodyInserter<Object, MockClientHttpRequest>) dataUtils.parseMultipartFileData(properties);
+        MockClientHttpRequest request = new MockClientHttpRequest(HttpMethod.POST, URI.create("https://example.com"));
+
+        Mono<Void> result = bodyInserter.insert(request, this.context);
+        StepVerifier.create(result).expectComplete().verify();
+        StepVerifier.create(DataBufferUtils.join(request.getBody()))
+                .consumeNextWith(dataBuffer -> {
+                    byte[] resultBytes = new byte[dataBuffer.readableByteCount()];
+                    dataBuffer.read(resultBytes);
+                    DataBufferUtils.release(dataBuffer);
+                    String content = new String(resultBytes, StandardCharsets.UTF_8);
+                    assertTrue(content.contains(
+                            "Content-Disposition: form-data; name=\"fileField\"; filename=\"test.pdf\""));
+                    assertTrue(content.contains("Content-Type: application/pdf"));
+                })
+                .expectComplete()
+                .verify();
+    }
 }

app/server/appsmith-interfaces/src/test/java/com/appsmith/external/helpers/MustacheHelperTest.java

@@ -608,15 +608,80 @@ public void render_WhenValueContainsHtmlDoubleQuotes_ReturnsEscapedCharacter() {
     }
 
     /**
-     * This test case validates the unescaping of HTML characters to string
+     * Verifies that HTML entities other than "/" are NOT decoded.
+     * Previously, unescapeHtml4() decoded all entities, but this corrupted binary data
+     * containing entity-like byte sequences (e.g., 
 in PDFs). Now only " and
+     * " are handled for JSON validity.
+     * See: https://linear.app/appsmith/issue/V2-3662
      */
     @Test
-    public void render_WhenValueContainsHtmlReservedCharacters_ReturnsEscapedCharacters() {
+    public void render_WhenValueContainsHtmlReservedCharacters_DoesNotDecodeNonQuoteEntities() {
         final String rendered = render(
                 "Testing html lt {{ltSymbol}} and gt {{gtSymbol}} symbols",
                 Map.of(
                         "ltSymbol", "<",
                         "gtSymbol", ">"));
-        assertThat(rendered).isEqualTo("Testing html lt < and gt > symbols");
+        assertThat(rendered).isEqualTo("Testing html lt &lt; and gt &gt; symbols");
+    }
+
+    /**
+     * This test verifies that binary data containing HTML-entity-like byte sequences
+     * (e.g., &#xA; which is a newline entity) is NOT corrupted by the render method.
+     * PDF files and other binary content may contain such sequences as raw bytes.
+     * Regression test for: https://linear.app/appsmith/issue/V2-3662
+     */
+    @Test
+    public void render_WhenBinaryDataContainsHtmlEntityLikeSequences_DoesNotCorruptData() {
+        String binaryDataWithEntity = "[{\"name\":\"test.pdf\",\"type\":\"application/pdf\","
+                + "\"data\":\"some-binary-prefix\u0026#xA;some-binary-suffix\"}]";
+
+        final String rendered = render("{{filePicker.files}}", Map.of("filePicker.files", binaryDataWithEntity));
+
+        assertThat(rendered).isEqualTo(binaryDataWithEntity);
+        assertThat(rendered).contains("&#xA;");
+        assertThat(rendered).doesNotContain("\n");
+    }
+
+    /**
+     * Verifies that other HTML numeric character references in binary content
+     * are not decoded (e.g., &#xD; for carriage return, &#9; for tab).
+     */
+    @Test
+    public void render_WhenBinaryDataContainsVariousHtmlEntities_DoesNotCorruptData() {
+        String dataWithEntities = "prefix&#xD;middle&#9;suffix&amp;end&lt;final&gt;done";
+
+        final String rendered = render("{{data}}", Map.of("data", dataWithEntities));
+
+        assertThat(rendered).isEqualTo(dataWithEntities);
+    }
+
+    /**
+     * Proves the JSON-quote escape is scoped to binding values only. When the template
+     * contains a literal &quot; AND the binding value also contains a &quot;, only the
+     * value is mutated; the literal is preserved byte-for-byte.
+     * Regression test for: V2-3662 (follow-up)
+     */
+    @Test
+    public void render_WhenTemplateLiteralAndValueBothContainQuoteEntity_OnlyValueIsEscaped() {
+        final String rendered = render("literal &quot; then {{data}} end", Map.of("data", "A&quot;B"));
+
+        // Template literal preserved
+        assertThat(rendered).startsWith("literal &quot; then ");
+        assertThat(rendered).endsWith(" end");
+        // Binding value escaped for JSON validity
+        assertThat(rendered).contains("A\\\"B");
+        assertThat(rendered).isEqualTo("literal &quot; then A\\\"B end");
+    }
+
+    /**
+     * A literal &quot; sitting in the template text (not inside a mustache binding)
+     * must pass through unchanged. Only binding values participate in JSON-validity
+     * escaping.
+     */
+    @Test
+    public void render_WhenTemplateLiteralContainsQuoteEntity_IsPreserved() {
+        final String rendered = render("static &quot;literal&quot; {{k}}", Map.of("k", "v"));
+
+        assertThat(rendered).isEqualTo("static &quot;literal&quot; v");
     }
 }