feat(ExifTool): add capability to overwrite metadata of the PDF generated (#776)

* add new metadata functions to pdf engine interface

* add exiftool module with relevant test cases

* use exiftool to overwrite metadata in libreoffice

* use exiftool to overwrite metadata in chromium

* fix linter issues

* fix more linter issues

* more test cases for better coverage

* remove utils

* minor changes

* remove metadata from pdfoptions

* correct indentation

* read/write metadata one file at a time.

pkg/modules/chromium/routes.go

@@ -233,6 +233,23 @@ func FormDataChromiumPdfFormats(form *api.FormData) gotenberg.PdfFormats {
 	}
 }
 
+// FormDataMetadata creates metadata object from the form data.
+func FormDataMetadata(form *api.FormData) map[string]interface{} {
+	var metadata map[string]interface{}
+
+	form.Custom("metadata", func(value string) error {
+		metadata = map[string]interface{}{}
+		if len(value) > 0 {
+			err := json.Unmarshal([]byte(value), &metadata)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return metadata
+}
+
 // convertUrlRoute returns an [api.Route] which can convert a URL to PDF.
 func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
@@ -243,6 +260,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataMetadata(form)
 
 			var url string
 			err := form.
@@ -252,7 +270,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options, metadata)
 			if err != nil {
 				return fmt.Errorf("convert URL to PDF: %w", err)
 			}
@@ -302,6 +320,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataMetadata(form)
 
 			var inputPath string
 			err := form.
@@ -312,7 +331,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			}
 
 			url := fmt.Sprintf("file://%s", inputPath)
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options, metadata)
 			if err != nil {
 				return fmt.Errorf("convert HTML to PDF: %w", err)
 			}
@@ -363,6 +382,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
 			pdfFormats := FormDataChromiumPdfFormats(form)
+			metadata := FormDataMetadata(form)
 
 			var (
 				inputPath     string
@@ -382,7 +402,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options)
+			err = convertUrl(ctx, chromium, engine, url, pdfFormats, options, metadata)
 			if err != nil {
 				return fmt.Errorf("convert markdown to PDF: %w", err)
 			}
@@ -506,7 +526,7 @@ func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string)
 	return fmt.Sprintf("file://%s", inputPath), nil
 }
 
-func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, pdfFormats gotenberg.PdfFormats, options PdfOptions) error {
+func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, pdfFormats gotenberg.PdfFormats, options PdfOptions, metadata map[string]interface{}) error {
 	outputPath := ctx.GeneratePath(".pdf")
 
 	err := chromium.Pdf(ctx, ctx.Log(), url, outputPath, options)
@@ -562,6 +582,14 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		outputPath = convertOutputPath
 	}
 
+	// Writes and potentially overrides metadata entries, if any.
+	if len(metadata) > 0 {
+		err = engine.WriteMetadata(ctx, ctx.Log(), outputPath, metadata)
+		if err != nil {
+			return fmt.Errorf("write metadata: %w", err)
+		}
+	}
+
 	err = ctx.AddOutputPaths(outputPath)
 	if err != nil {
 		return fmt.Errorf("add output path: %w", err)

pkg/modules/chromium/routes_test.go

@@ -1225,6 +1225,7 @@ func TestConvertUrl(t *testing.T) {
 		engine                 gotenberg.PdfEngine
 		pdfFormats             gotenberg.PdfFormats
 		options                PdfOptions
+		metadata               map[string]interface{}
 		expectError            bool
 		expectHttpError        bool
 		expectHttpStatus       int
@@ -1385,10 +1386,45 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "error with metadata write",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+				return fmt.Errorf("error writing metadata to %s: %w", "foo.pdf", errors.New("foo"))
+			}},
+			options: DefaultPdfOptions(),
+			metadata: map[string]interface{}{
+				"Creator":  "foo",
+				"Producer": "bar",
+			},
+			expectError:     true,
+			expectHttpError: false,
+		},
+		{
+			scenario: "success with metadata write",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+				return nil
+			}},
+			options: DefaultPdfOptions(),
+			metadata: map[string]interface{}{
+				"Creator":  "foo",
+				"Producer": "bar",
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.pdfFormats, tc.options)
+			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.pdfFormats, tc.options, tc.metadata)
 
 			if tc.expectError && err == nil {
 				t.Fatal("expected error but got none", err)

pkg/modules/exiftool/doc.go

@@ -0,0 +1,8 @@
+// Package exiftool provides an implementation of the gotenberg.PdfEngine
+// interface using the ExifTool command-line tool. This package allows for reading and
+// writing of metadata, but does not support the merging of PDF files
+// nor conversion to specific PDF formats. The path to the exiftool binary must be
+// specified using the EXIFTOOL_BIN_PATH environment variable.
+//
+// See: https://exiftool.org.
+package exiftool

pkg/modules/exiftool/exiftool.go

@@ -0,0 +1,194 @@
+package exiftool
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+
+	"github.com/barasher/go-exiftool"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(new(ExifTool))
+}
+
+// MetadataValueTypeError is constructed when metadata value types cannot be processed.
+// The underlying library used in this implementation supports the writing of a limited
+// number of metadata value types.
+//
+// For example, according to https://exiftool.org/TagNames/PDF.html metadata can be a boolean,
+// i.e. "value format... may be string, date, integer, real, boolean or name".
+// Furthermore, a native boolean type is also supported by JSON and Go. However, the
+// underlying library does not currently support writing native Go boolean (bool) types.
+// Therefore, an instance of this struct is created when a boolean metadata entry is supplied.
+//
+// The struct contains a key/value map corresponding to individual invalid metadata entries supplied by a consumer.
+// This allows a helpful error message to be produced for API consumers.
+// See API.WriteMetadata for more information on valid metadata value types.
+type MetadataValueTypeError struct {
+	Entries map[string]interface{}
+}
+
+// Error returns a helpful error message.
+func (e *MetadataValueTypeError) Error() string {
+	return fmt.Sprintf("invalid metadata value types supplied - identified by Entries: %s", e.Entries)
+}
+
+// GetKeys returns an array of keys with corresponding invalid value types,
+func (e *MetadataValueTypeError) GetKeys() []string {
+	keys := make([]string, len(e.Entries))
+	i := 0
+	for key := range e.Entries {
+		keys[i] = key
+		i++
+	}
+	return keys
+}
+
+// ExifTool abstracts the CLI tool ExifTool and implements the [gotenberg.PdfEngine] interface .
+type ExifTool struct {
+	binPath string
+}
+
+// Descriptor returns ExifTool's module descriptor.
+func (engine *ExifTool) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID:  "exiftool",
+		New: func() gotenberg.Module { return new(ExifTool) },
+	}
+}
+
+// Provision sets the module properties. It returns an error if
+// - the environment variable EXIFTOOL_BIN_PATH is not set
+// - there is an error creating an instance of exiftool.ExifTool
+func (engine *ExifTool) Provision(ctx *gotenberg.Context) error {
+	binPath, ok := os.LookupEnv("EXIFTOOL_BIN_PATH")
+	if !ok {
+		return errors.New("EXIFTOOL_BIN_PATH environment variable is not set")
+	}
+
+	engine.binPath = binPath
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (engine *ExifTool) Validate() error {
+	_, err := os.Stat(engine.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("ExifTool binary path does not exist: %w", err)
+	}
+
+	return nil
+}
+
+// Merge is not available in this implementation.
+func (engine *ExifTool) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// Convert is not available in this implementation.
+func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// ReadMetadata reads the metadata of the given PDF files.
+func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+	logger.Debug(fmt.Sprintf("reading metadata of file: %s", inputPath))
+
+	exifTool, err := exiftool.NewExiftool()
+	if err != nil {
+		fmt.Printf("Error intializing ExifTool: %v\n", err)
+		return err
+	}
+
+	fileMetadataInfos := exifTool.ExtractMetadata([]string{inputPath}...)
+
+	if fileMetadataInfos[0].Err != nil {
+		return fmt.Errorf("error reading metadata to following file: %+v", fileMetadataInfos[0])
+	}
+
+	// load into metadata
+	for k, v := range fileMetadataInfos[0].Fields {
+		metadata[k] = v
+	}
+
+	return exifTool.Close()
+}
+
+// WriteMetadata write the metadata to the given PDF files.
+func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+	logger.Debug(fmt.Sprintf("writing new metadata %s to %s", newMetadata, inputPath))
+
+	exifTool, err := exiftool.NewExiftool()
+	if err != nil {
+		fmt.Printf("Error intializing ExifTool: %v\n", err)
+		return err
+	}
+
+	fileMetadataInfos := exifTool.ExtractMetadata([]string{inputPath}...)
+
+	// there is only file metadata info
+	if fileMetadataInfos[0].Err != nil {
+		return fmt.Errorf("error reading metadata to following file: %+v", fileMetadataInfos[0])
+	}
+
+	// Metadata values can only be specific value types.
+	// An error is returned if metadata with an invalid type is requested.
+	metadataValueErrors := MetadataValueTypeError{
+		Entries: make(map[string]interface{}),
+	}
+
+	// transform metadata
+	for key, value := range newMetadata {
+		switch val := value.(type) {
+		case string:
+			fileMetadataInfos[0].SetString(key, val)
+		case int:
+			fileMetadataInfos[0].SetInt(key, int64(val))
+		case int64:
+			fileMetadataInfos[0].SetInt(key, val)
+		case float32:
+			fileMetadataInfos[0].SetFloat(key, float64(val))
+		case float64:
+			fileMetadataInfos[0].SetFloat(key, val)
+		case []string:
+			fileMetadataInfos[0].SetStrings(key, val)
+		// TODO: support more complex cases, e.g. arrays and nested objects (limitations in underlying library)
+		default:
+			metadataValueErrors.Entries[key] = value
+		}
+	}
+	logger.Debug(fmt.Sprintf("writing metadata %s to %s", fileMetadataInfos[0].Fields, fileMetadataInfos[0].File))
+
+	if len(metadataValueErrors.Entries) > 0 {
+		return api.WrapError(
+			fmt.Errorf("write metadata: %w", err),
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("Invalid metdata value types supplied by keys '%s'", metadataValueErrors.GetKeys())),
+		)
+	}
+
+	exifTool.WriteMetadata(fileMetadataInfos)
+
+	if fileMetadataInfos[0].Err != nil {
+		return fmt.Errorf("error writing metadata to following file: %+v", fileMetadataInfos[0])
+	}
+
+	return exifTool.Close()
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*ExifTool)(nil)
+	_ gotenberg.Provisioner = (*ExifTool)(nil)
+	_ gotenberg.Validator   = (*ExifTool)(nil)
+	_ gotenberg.PdfEngine   = (*ExifTool)(nil)
+)

pkg/modules/exiftool/exiftool_test.go

@@ -0,0 +1,418 @@
+package exiftool
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestMetadataValueTypeError_Error(t *testing.T) {
+	instance := MetadataValueTypeError{
+		Entries: map[string]interface{}{
+			"foo": "foo",
+		},
+	}
+
+	assert.True(t, len(instance.Error()) > 0)
+}
+
+func TestMetadataValueTypeError_GetKeys(t *testing.T) {
+	for i, tc := range []struct {
+		instance MetadataValueTypeError
+		expect   []string
+	}{
+		{
+			instance: MetadataValueTypeError{
+				Entries: map[string]interface{}{},
+			},
+			expect: []string{},
+		},
+		{
+			instance: MetadataValueTypeError{
+				Entries: map[string]interface{}{
+					"foo": "foo",
+				},
+			},
+			expect: []string{"foo"},
+		},
+		{
+			instance: MetadataValueTypeError{
+				Entries: map[string]interface{}{
+					"foo":  "foo",
+					"bar":  float64(123),
+					"baz":  4.56,
+					"qux":  true,
+					"quux": nil,
+				},
+			},
+			expect: []string{"foo", "bar", "baz", "qux", "quux"},
+		},
+	} {
+		actual := tc.instance.GetKeys()
+
+		if !assert.ElementsMatch(t, actual, tc.expect) {
+			t.Errorf("test %d: expected %+v but got: %+v", i, tc.expect, actual)
+		}
+	}
+}
+
+func TestExifTool_Descriptor(t *testing.T) {
+	descriptor := new(ExifTool).Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(ExifTool))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestExifTool_Provision(t *testing.T) {
+	engine := new(ExifTool)
+	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)
+
+	err := engine.Provision(ctx)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestExifTool_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
+	}{
+		{
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
+		},
+		{
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
+		},
+		{
+			scenario:    "validate success",
+			binPath:     os.Getenv("EXIFTOOL_BIN_PATH"),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			engine.binPath = tc.binPath
+			err := engine.Validate()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestExiftool_Merge(t *testing.T) {
+	engine := new(ExifTool)
+	err := engine.Merge(context.Background(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestExiftool_Convert(t *testing.T) {
+	engine := new(ExifTool)
+	err := engine.Convert(context.Background(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestExiftool_ReadMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         context.Context
+		inputPath   string
+		subset      map[string]interface{}
+		expectError bool
+		expectDiff  bool
+	}{
+		{
+			scenario:    "invalid input path",
+			ctx:         context.TODO(),
+			inputPath:   "foo",
+			expectError: true,
+		},
+		{
+			scenario:  "single file success",
+			ctx:       context.TODO(),
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			subset: map[string]interface{}{
+				"FileName":          "sample1.pdf",
+				"FileTypeExtension": "pdf",
+				"MIMEType":          "application/pdf",
+				"PDFVersion":        1.4,
+				"PageCount":         float64(3),
+				"CreateDate":        "2018:12:06 17:50:06+00:00",
+				"ModifyDate":        "2018:12:06 17:50:06+00:00",
+				"Directory":         "/tests/test/testdata/pdfengines",
+				"FileType":          "PDF",
+				"Linearized":        "No",
+				"Creator":           "Chromium",
+				"Producer":          "Skia/PDF m70",
+				"SourceFile":        "/tests/test/testdata/pdfengines/sample1.pdf",
+			},
+		},
+		{
+			scenario:  "single file incorrect metadata",
+			ctx:       context.TODO(),
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			subset: map[string]interface{}{
+				"FileName":          "sample1.pdf",
+				"FileTypeExtension": "pdf",
+				"MIMEType":          "application/pdf",
+				"PDFVersion":        1.4,
+				"PageCount":         float64(3),
+				"CreateDate":        "2018:12:06 17:50:06+00:00",
+				"ModifyDate":        "2018:12:06 17:50:06+00:00",
+				"Directory":         "/tests/test/testdata/pdfengines",
+				"FileType":          "PDF",
+				"Linearized":        "No",
+				"Creator":           "INVALID",
+				"Producer":          "Skia/PDF m70",
+				"SourceFile":        "/tests/test/testdata/pdfengines/sample1.pdf",
+			},
+			expectDiff: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			actualMetadata := map[string]interface{}{}
+			err = engine.ReadMetadata(tc.ctx, zap.NewNop(), tc.inputPath, actualMetadata)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.subset != nil && err == nil {
+				if !tc.expectDiff && !isMapSubset(actualMetadata, tc.subset) {
+					t.Errorf("test: %s: expected: %+v to be a subset of: %+v at path: %s",
+						tc.scenario, tc.subset, actualMetadata, tc.inputPath)
+				} else if tc.expectDiff && isMapSubset(actualMetadata, tc.subset) {
+					t.Errorf("test: %s: expected: %+v to be not be a subset of: %+v at path: %s",
+						tc.scenario, tc.subset, actualMetadata, tc.inputPath)
+				}
+			}
+		})
+	}
+}
+
+func TestExiftool_WriteMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         context.Context
+		inputPath   string
+		newMetadata map[string]interface{}
+		contains    map[string]interface{}
+		expectError bool
+		expectDiff  bool
+	}{
+		{
+			scenario:  "single file success",
+			ctx:       context.TODO(),
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			newMetadata: map[string]interface{}{
+				"Producer": "foo",
+			},
+			contains: map[string]interface{}{
+				"Producer": "foo",
+			},
+			expectError: false,
+			expectDiff:  false,
+		},
+		{
+			scenario:  "single file not same metadata",
+			ctx:       context.TODO(),
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			newMetadata: map[string]interface{}{
+				"Producer": "foo",
+			},
+			contains: map[string]interface{}{
+				"Producer": "foobar",
+			},
+			expectError: false,
+			expectDiff:  true,
+		},
+		{
+			scenario:  "single file unknown type",
+			ctx:       context.TODO(),
+			inputPath: "/tests/test/testdata/pdfengines/sample1.pdf",
+			newMetadata: map[string]interface{}{
+				"foo": map[string]string{},
+			},
+			expectError: true,
+			expectDiff:  false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(ExifTool)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			fs := gotenberg.NewFileSystem()
+			outputDir, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			defer func() {
+				err = os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			copyPath := fmt.Sprintf("%s/copy_temp.pdf", outputDir)
+			// open the source file
+			source, err := os.Open(tc.inputPath)
+			if err != nil {
+				t.Fatalf("error in opening file: %v", err)
+			}
+
+			// create the destination file
+			destination, err := os.Create(copyPath)
+			if err != nil {
+				t.Fatalf("error in creating file: %v", err)
+			}
+
+			// copy the contents of source to destination file
+			_, err = io.Copy(destination, source)
+			if err != nil {
+				t.Fatalf("error in copying file: %v", err)
+			}
+
+			err = source.Close()
+			if err != nil {
+				t.Fatalf("error in source file close: %v", err)
+			}
+			err = destination.Close()
+			if err != nil {
+				t.Fatalf("error in destination file close: %v", err)
+			}
+
+			// write metadata to new copy files
+			err = engine.WriteMetadata(tc.ctx, zap.NewNop(), copyPath, tc.newMetadata)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if err == nil {
+				readMetadata := map[string]interface{}{}
+				readErr := engine.ReadMetadata(tc.ctx, zap.NewNop(), copyPath, readMetadata)
+				if tc.contains != nil && readErr == nil {
+					// match metadata
+					if !tc.expectDiff && !isMapSubset(readMetadata, tc.contains) {
+						t.Errorf("test: %s: expected: %+v to be a subset of: %+v at path: %s",
+							tc.scenario, tc.contains, readMetadata, copyPath)
+					} else if tc.expectDiff && isMapSubset(readMetadata, tc.contains) {
+						t.Errorf("test: %s: expected: %+v to be not be a subset of: %+v at path: %s",
+							tc.scenario, tc.contains, readMetadata, copyPath)
+					}
+				}
+			}
+		})
+	}
+}
+
+func isMapSubset(mapSet interface{}, mapSubset interface{}) bool {
+	mapSetValue := reflect.ValueOf(mapSet)
+	mapSubsetValue := reflect.ValueOf(mapSubset)
+
+	if mapSetValue.Kind() != reflect.Map || mapSubsetValue.Kind() != reflect.Map {
+		return false
+	}
+	if reflect.TypeOf(mapSetValue) != reflect.TypeOf(mapSubsetValue) {
+		return false
+	}
+	if len(mapSubsetValue.MapKeys()) == 0 {
+		return true
+	}
+
+	iterMapSubset := mapSubsetValue.MapRange()
+
+	for iterMapSubset.Next() {
+		k := iterMapSubset.Key()
+		v := iterMapSubset.Value()
+
+		v2 := mapSetValue.MapIndex(k)
+
+		if !v2.IsValid() {
+			return false
+		}
+		if isValueKind(v, reflect.Slice) && isValueKind(v2, reflect.Slice) {
+			vSlice := convertSlice(v)
+			v2Slice := convertSlice(v2)
+			if !equal(vSlice, v2Slice) {
+				return false
+			}
+		} else if v.Interface() != v2.Interface() {
+			return false
+		}
+	}
+
+	return true
+}
+
+func isValueKind(value reflect.Value, kind reflect.Kind) bool {
+	return reflect.TypeOf(value.Interface()).Kind() == kind
+}
+
+func convertSlice(value reflect.Value) []interface{} {
+	slice := make([]interface{}, reflect.ValueOf(value.Interface()).Len())
+	for i := range slice {
+		slice = append(slice, reflect.ValueOf(value.Interface()).Index(i).Interface())
+	}
+	return slice
+}
+
+// equal tells whether a and b contain the same elements.
+// A nil argument is equivalent to an empty slice.
+func equal(a, b []interface{}) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, v := range a {
+		if v != b[i] {
+			return false
+		}
+	}
+	return true
+}

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -71,6 +71,16 @@ func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Log
 	return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, err)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, metadata map[string]interface{}) error {
+	return fmt.Errorf("read PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, newMetadata map[string]interface{}) error {
+	return fmt.Errorf("write PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*LibreOfficePdfEngine)(nil)

pkg/modules/libreoffice/pdfengine/pdfengine_test.go

@@ -166,3 +166,21 @@ func TestLibreOfficePdfEngine_Convert(t *testing.T) {
 		})
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	err := engine.ReadMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/libreoffice/routes.go

@@ -1,6 +1,7 @@
 package libreoffice
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -27,22 +28,33 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				inputPaths       []string
 				landscape        bool
 				nativePageRanges string
+				exportFormFields bool
 				pdfa             string
 				pdfua            bool
 				nativePdfFormats bool
 				merge            bool
-				exportFormFields bool
+				metadata         map[string]interface{}
 			)
 
 			err := ctx.FormData().
 				MandatoryPaths(libreOffice.Extensions(), &inputPaths).
 				Bool("landscape", &landscape, false).
 				String("nativePageRanges", &nativePageRanges, "").
+				Bool("exportFormFields", &exportFormFields, true).
 				String("pdfa", &pdfa, "").
 				Bool("pdfua", &pdfua, false).
 				Bool("nativePdfFormats", &nativePdfFormats, true).
 				Bool("merge", &merge, false).
-				Bool("exportFormFields", &exportFormFields, true).
+				Custom("metadata", func(value string) error {
+					metadata = map[string]interface{}{}
+					if len(value) > 0 {
+						err := json.Unmarshal([]byte(value), &metadata)
+						if err != nil {
+							return err
+						}
+					}
+					return nil
+				}).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
@@ -116,6 +128,14 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 					outputPath = convertOutputPath
 				}
 
+				// Writes and potentially overrides metadata entries, if any.
+				if len(metadata) > 0 {
+					err = engine.WriteMetadata(ctx, ctx.Log(), outputPath, metadata)
+					if err != nil {
+						return fmt.Errorf("write metadata failure: %w", err)
+					}
+				}
+
 				// Last but not least, add the output path to the context so that
 				// the API is able to send it as a response to the client.
 				err = ctx.AddOutputPaths(outputPath)
@@ -160,6 +180,16 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}
 
+			// Writes and potentially overrides metadata entries, if any.
+			if len(metadata) > 0 {
+				for _, outputPath := range outputPaths {
+					err = engine.WriteMetadata(ctx, ctx.Log(), outputPath, metadata)
+					if err != nil {
+						return fmt.Errorf("write metadata: %w", err)
+					}
+				}
+			}
+
 			// Last but not least, add the output paths to the context so that
 			// the API is able to send them as a response to the client.
 			err = ctx.AddOutputPaths(outputPaths...)

pkg/modules/libreoffice/routes_test.go

@@ -546,6 +546,315 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "success with metadata (single file)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
+		{
+			scenario: "success with metadata (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 2,
+		},
+		{
+			scenario: "error with metadata (single file)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						// invalid json
+						"{\"Creator\"",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error with metadata (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						// invalid json
+						"{\"Creator\"",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error with metadata write failure (single file)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error with metadata write failure (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "success merge with metadata",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
+		{
+			scenario: "error merge with metadata",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"metadata": {
+						// invalid json
+						"{\"Creator",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error merge with metadata write failure",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())

pkg/modules/pdfcpu/pdfcpu.go

@@ -54,6 +54,16 @@ func (engine *PdfCpu) Convert(ctx context.Context, logger *zap.Logger, formats g
 	return fmt.Errorf("convert PDF to '%+v' with PDFcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, metadata map[string]interface{}) error {
+	return fmt.Errorf("read PDF metadata with PDFcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, newMetadata map[string]interface{}) error {
+	return fmt.Errorf("write PDF metadata with PDFcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*PdfCpu)(nil)

pkg/modules/pdfcpu/pdfcpu_test.go

@@ -102,3 +102,21 @@ func TestPdfCpu_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(PdfCpu)
+	err := engine.ReadMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(PdfCpu)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/pdfengines/multi.go

@@ -70,6 +70,52 @@ func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, f
 	return fmt.Errorf("convert PDF to '%+v' with multi PDF engines: %w", formats, err)
 }
 
+func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, metadata map[string]interface{}) error {
+	var err error
+	errChan := make(chan error, 1)
+
+	for _, engine := range multi.engines {
+		go func(engine gotenberg.PdfEngine) {
+			errChan <- engine.ReadMetadata(ctx, logger, inputPaths, metadata)
+		}(engine)
+
+		select {
+		case readMetadataErr := <-errChan:
+			errored := multierr.AppendInto(&err, readMetadataErr)
+			if !errored {
+				return nil
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	return fmt.Errorf("read PDF metadata with multi PDF engines: %w", err)
+}
+
+func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, newMetadata map[string]interface{}) error {
+	var err error
+	errChan := make(chan error, 1)
+
+	for _, engine := range multi.engines {
+		go func(engine gotenberg.PdfEngine) {
+			errChan <- engine.WriteMetadata(ctx, logger, inputPaths, newMetadata)
+		}(engine)
+
+		select {
+		case writeMetadataErr := <-errChan:
+			errored := multierr.AppendInto(&err, writeMetadataErr)
+			if !errored {
+				return nil
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	return fmt.Errorf("write PDF metadata with multi PDF engines: %w", err)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.PdfEngine = (*multiPdfEngines)(nil)

pkg/modules/pdfengines/multi_test.go

@@ -177,3 +177,169 @@ func TestMultiPdfEngines_Convert(t *testing.T) {
 		})
 	}
 }
+
+func TestMultiPdfEngines_ReadMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, metadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.ReadMetadata(tc.ctx, zap.NewNop(), "", nil)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_WriteMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return errors.New("foo")
+					},
+				},
+			),
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: newMultiPdfEngines(
+				&gotenberg.PdfEngineMock{
+					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string, newMetadata map[string]interface{}) error {
+						return nil
+					},
+				},
+			),
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.WriteMetadata(tc.ctx, zap.NewNop(), "", nil)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}

pkg/modules/pdftk/pdftk.go

@@ -75,6 +75,16 @@ func (engine *PdfTk) Convert(ctx context.Context, logger *zap.Logger, formats go
 	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, metadata map[string]interface{}) error {
+	return fmt.Errorf("read PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, newMetadata map[string]interface{}) error {
+	return fmt.Errorf("write PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Interface guards.
 var (
 	_ gotenberg.Module      = (*PdfTk)(nil)

pkg/modules/pdftk/pdftk_test.go

@@ -148,3 +148,21 @@ func TestPdfTk_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(PdfTk)
+	err := engine.ReadMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(PdfTk)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}

pkg/modules/qpdf/qpdf.go

@@ -77,6 +77,16 @@ func (engine *QPdf) Convert(ctx context.Context, logger *zap.Logger, formats got
 	return fmt.Errorf("convert PDF to '%+v' with QPDF: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
+// ReadMetadata is not available in this implementation.
+func (engine *QPdf) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, metadata map[string]interface{}) error {
+	return fmt.Errorf("read PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
+// WriteMetadata is not available in this implementation.
+func (engine *QPdf) WriteMetadata(ctx context.Context, logger *zap.Logger, inputPaths string, newMetadata map[string]interface{}) error {
+	return fmt.Errorf("write PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 var (
 	_ gotenberg.Module      = (*QPdf)(nil)
 	_ gotenberg.Provisioner = (*QPdf)(nil)

pkg/modules/qpdf/qpdf_test.go

@@ -148,3 +148,21 @@ func TestQPdf_Convert(t *testing.T) {
 		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
 	}
 }
+
+func TestLibreOfficePdfEngine_ReadMetadata(t *testing.T) {
+	engine := new(QPdf)
+	err := engine.ReadMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
+func TestLibreOfficePdfEngine_WriteMetadata(t *testing.T) {
+	engine := new(QPdf)
+	err := engine.WriteMetadata(context.Background(), zap.NewNop(), "", nil)
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}