fix(pdfengines): better workflow when applying PDF/A or PDF/UA compliance

pkg/modules/chromium/routes.go

@@ -781,24 +781,36 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		return fmt.Errorf("convert to PDF: %w", err)
 	}
 
+	err = pdfengines.ValidatePdfFormatsCompat(pdfFormats, userPassword, embedPaths)
+	if err != nil {
+		return err
+	}
+
 	outputPaths, err := pdfengines.SplitPdfStub(ctx, engine, mode, []string{outputPath})
 	if err != nil {
 		return fmt.Errorf("split PDF: %w", err)
 	}
 
+	err = pdfengines.WatermarkStub(ctx, engine, watermark, outputPaths)
+	if err != nil {
+		return fmt.Errorf("watermark PDFs: %w", err)
+	}
+
+	err = pdfengines.StampStub(ctx, engine, stamp, outputPaths)
+	if err != nil {
+		return fmt.Errorf("stamp PDFs: %w", err)
+	}
+
 	convertOutputPaths, err := pdfengines.ConvertStub(ctx, engine, pdfFormats, outputPaths)
 	if err != nil {
 		return fmt.Errorf("convert PDF(s): %w", err)
 	}
 
-	err = pdfengines.WatermarkStub(ctx, engine, watermark, convertOutputPaths)
+	// Metadata, embeds are written after Convert, as LibreOffice
+	// strips them during PDF/A conversion.
+	err = pdfengines.WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
 	if err != nil {
-		return fmt.Errorf("watermark PDFs: %w", err)
-	}
-
-	err = pdfengines.StampStub(ctx, engine, stamp, convertOutputPaths)
-	if err != nil {
-		return fmt.Errorf("stamp PDFs: %w", err)
+		return fmt.Errorf("write metadata: %w", err)
 	}
 
 	err = pdfengines.EmbedFilesStub(ctx, engine, embedPaths, convertOutputPaths)
@@ -806,11 +818,6 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		return fmt.Errorf("embed files into PDFs: %w", err)
 	}
 
-	err = pdfengines.WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
-	if err != nil {
-		return fmt.Errorf("write metadata: %w", err)
-	}
-
 	err = pdfengines.EncryptPdfStub(ctx, engine, userPassword, ownerPassword, convertOutputPaths)
 	if err != nil {
 		return fmt.Errorf("encrypt PDFs: %w", err)

pkg/modules/libreoffice/routes.go

@@ -195,6 +195,14 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				stamp.Expression = stampFiles[0]
 			}
 
+			err = pdfengines.ValidatePdfFormatsCompat(pdfFormats, userPassword, embedPaths)
+			if err != nil {
+				return err
+			}
+
+			hasPostProcessing := watermark.Source != "" || stamp.Source != "" ||
+				len(embedPaths) > 0 || len(metadata) > 0 || flatten
+
 			outputPaths := make([]string, len(inputPaths))
 			for i, inputPath := range inputPaths {
 				outputPaths[i] = ctx.GeneratePath(".pdf")
@@ -230,9 +238,10 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 					NativeTiledWatermarkText:        nativeTiledWatermarkText,
 				}
 
-				if nativePdfFormats && splitMode == zeroValuedSplitMode {
+				if nativePdfFormats && splitMode == zeroValuedSplitMode && !hasPostProcessing {
 					// Only natively apply given PDF formats if we're not
-					// splitting the PDF later.
+					// splitting the PDF later and no post-processing features
+					// are enabled (as they would degrade compliance).
 					options.PdfFormats = pdfFormats
 				}
 
@@ -298,7 +307,27 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}
 
-			if !nativePdfFormats || (nativePdfFormats && splitMode != zeroValuedSplitMode) {
+			err = pdfengines.WatermarkStub(ctx, engine, watermark, outputPaths)
+			if err != nil {
+				return fmt.Errorf("watermark PDFs: %w", err)
+			}
+
+			err = pdfengines.StampStub(ctx, engine, stamp, outputPaths)
+			if err != nil {
+				return fmt.Errorf("stamp PDFs: %w", err)
+			}
+
+			if flatten {
+				err = pdfengines.FlattenStub(ctx, engine, outputPaths)
+				if err != nil {
+					return fmt.Errorf("flatten PDFs: %w", err)
+				}
+			}
+
+			needsConvertStub := !nativePdfFormats ||
+				(nativePdfFormats && splitMode != zeroValuedSplitMode) ||
+				(nativePdfFormats && hasPostProcessing)
+			if needsConvertStub {
 				convertOutputPaths, err := pdfengines.ConvertStub(ctx, engine, pdfFormats, outputPaths)
 				if err != nil {
 					return fmt.Errorf("convert PDFs: %w", err)
@@ -318,31 +347,16 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}
 
-			err = pdfengines.WatermarkStub(ctx, engine, watermark, outputPaths)
-			if err != nil {
-				return fmt.Errorf("watermark PDFs: %w", err)
-			}
-
-			err = pdfengines.StampStub(ctx, engine, stamp, outputPaths)
-			if err != nil {
-				return fmt.Errorf("stamp PDFs: %w", err)
-			}
-
-			err = pdfengines.EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
-			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
-			}
-
+			// Metadata, embeds are written after Convert, as LibreOffice
+			// strips them during PDF/A conversion.
 			err = pdfengines.WriteMetadataStub(ctx, engine, metadata, outputPaths)
 			if err != nil {
 				return fmt.Errorf("write metadata: %w", err)
 			}
 
-			if flatten {
-				err = pdfengines.FlattenStub(ctx, engine, outputPaths)
-				if err != nil {
-					return fmt.Errorf("flatten PDFs: %w", err)
-				}
+			err = pdfengines.EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
+			if err != nil {
+				return fmt.Errorf("embed files into PDFs: %w", err)
 			}
 
 			err = pdfengines.EncryptPdfStub(ctx, engine, userPassword, ownerPassword, outputPaths)

pkg/modules/pdfengines/routes.go

@@ -166,6 +166,41 @@ func FormDataPdfBookmarks(form *api.FormData, mandatory bool) any {
 	return bookmarks
 }
 
+// ValidatePdfFormatsCompat checks for incompatible combinations of PDF formats
+// with other features and returns an appropriate error if found.
+func ValidatePdfFormatsCompat(pdfFormats gotenberg.PdfFormats, userPassword string, embedPaths []string) error {
+	zeroValued := gotenberg.PdfFormats{}
+	if pdfFormats == zeroValued {
+		return nil
+	}
+
+	// PDF/A forbids encryption per the standard.
+	if pdfFormats.PdfA != "" && userPassword != "" {
+		return api.WrapError(
+			errors.New("PDF/A format is incompatible with encryption"),
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				"Invalid form data: PDF/A format is incompatible with encryption",
+			),
+		)
+	}
+
+	// Only PDF/A-3 variants allow embedded file attachments.
+	if pdfFormats.PdfA != "" && len(embedPaths) > 0 {
+		if pdfFormats.PdfA != gotenberg.PdfA3a && pdfFormats.PdfA != gotenberg.PdfA3b && pdfFormats.PdfA != gotenberg.PdfA3u {
+			return api.WrapError(
+				fmt.Errorf("PDF format '%s' does not support embedded files", pdfFormats.PdfA),
+				api.NewSentinelHttpError(
+					http.StatusBadRequest,
+					fmt.Sprintf("Invalid form data: PDF format '%s' does not support embedded files; only PDF/A-3 variants allow attachments", pdfFormats.PdfA),
+				),
+			)
+		}
+	}
+
+	return nil
+}
+
 // MergeStub merges given PDFs. If only one input PDF, it does nothing and
 // returns the corresponding input path.
 func MergeStub(ctx *api.Context, engine gotenberg.PdfEngine, inputPaths []string) (string, error) {
@@ -546,16 +581,18 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				stamp.Expression = stampFiles[0]
 			}
 
+			err = ValidatePdfFormatsCompat(pdfFormats, userPassword, embedPaths)
+			if err != nil {
+				return err
+			}
+
 			outputPath := ctx.GeneratePath(".pdf")
 			err = engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
 			if err != nil {
 				return fmt.Errorf("merge PDFs: %w", err)
 			}
 
-			outputPaths, err := ConvertStub(ctx, engine, pdfFormats, []string{outputPath})
-			if err != nil {
-				return fmt.Errorf("convert PDF: %w", err)
-			}
+			outputPaths := []string{outputPath}
 
 			err = WatermarkStub(ctx, engine, watermark, outputPaths)
 			if err != nil {
@@ -567,11 +604,21 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("stamp PDFs: %w", err)
 			}
 
-			err = EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
-			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
+			if flatten {
+				err = FlattenStub(ctx, engine, outputPaths)
+				if err != nil {
+					return fmt.Errorf("flatten PDFs: %w", err)
+				}
 			}
 
+			outputPaths, err = ConvertStub(ctx, engine, pdfFormats, outputPaths)
+			if err != nil {
+				return fmt.Errorf("convert PDF: %w", err)
+			}
+
+			// Bookmarks, metadata, and embeds are written after Convert,
+			// as LibreOffice strips them during PDF/A conversion.
+
 			var finalBookmarks []gotenberg.Bookmark
 			if b, ok := bookmarks.([]gotenberg.Bookmark); ok {
 				finalBookmarks = b
@@ -620,11 +667,9 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("write metadata: %w", err)
 			}
 
-			if flatten {
-				err = FlattenStub(ctx, engine, outputPaths)
-				if err != nil {
-					return fmt.Errorf("flatten PDFs: %w", err)
-				}
+			err = EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
+			if err != nil {
+				return fmt.Errorf("embed files into PDFs: %w", err)
 			}
 
 			err = EncryptPdfStub(ctx, engine, userPassword, ownerPassword, outputPaths)
@@ -679,41 +724,48 @@ func splitRoute(engine gotenberg.PdfEngine) api.Route {
 				stamp.Expression = stampFiles[0]
 			}
 
+			err = ValidatePdfFormatsCompat(pdfFormats, userPassword, embedPaths)
+			if err != nil {
+				return err
+			}
+
 			outputPaths, err := SplitPdfStub(ctx, engine, mode, inputPaths)
 			if err != nil {
 				return fmt.Errorf("split PDFs: %w", err)
 			}
 
+			err = WatermarkStub(ctx, engine, watermark, outputPaths)
+			if err != nil {
+				return fmt.Errorf("watermark PDFs: %w", err)
+			}
+
+			err = StampStub(ctx, engine, stamp, outputPaths)
+			if err != nil {
+				return fmt.Errorf("stamp PDFs: %w", err)
+			}
+
+			if flatten {
+				err = FlattenStub(ctx, engine, outputPaths)
+				if err != nil {
+					return fmt.Errorf("flatten PDFs: %w", err)
+				}
+			}
+
 			convertOutputPaths, err := ConvertStub(ctx, engine, pdfFormats, outputPaths)
 			if err != nil {
 				return fmt.Errorf("convert PDFs: %w", err)
 			}
 
-			err = WatermarkStub(ctx, engine, watermark, convertOutputPaths)
-			if err != nil {
-				return fmt.Errorf("watermark PDFs: %w", err)
-			}
-
-			err = StampStub(ctx, engine, stamp, convertOutputPaths)
-			if err != nil {
-				return fmt.Errorf("stamp PDFs: %w", err)
-			}
-
-			err = EmbedFilesStub(ctx, engine, embedPaths, convertOutputPaths)
-			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
-			}
-
+			// Metadata, embeds are written after Convert, as LibreOffice
+			// strips them during PDF/A conversion.
 			err = WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
 			if err != nil {
 				return fmt.Errorf("write metadata: %w", err)
 			}
 
-			if flatten {
-				err = FlattenStub(ctx, engine, convertOutputPaths)
-				if err != nil {
-					return fmt.Errorf("flatten PDFs: %w", err)
-				}
+			err = EmbedFilesStub(ctx, engine, embedPaths, convertOutputPaths)
+			if err != nil {
+				return fmt.Errorf("embed files into PDFs: %w", err)
 			}
 
 			err = EncryptPdfStub(ctx, engine, userPassword, ownerPassword, convertOutputPaths)