feat: add 7.x source code

pkg/modules/libreoffice/doc.go

@@ -0,0 +1,3 @@
+// Package libreoffice provides a module which adds a route for converting
+// document to PDF with LibreOffice.
+package libreoffice

pkg/modules/libreoffice/libreoffice.go

@@ -0,0 +1,86 @@
+package libreoffice
+
+import (
+	"fmt"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	flag "github.com/spf13/pflag"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(LibreOffice{})
+}
+
+// LibreOffice is a module which provides a route for converting documents to
+// PDF with LibreOffice.
+type LibreOffice struct {
+	unoconv       unoconv.API
+	engine        gotenberg.PDFEngine
+	disableRoutes bool
+}
+
+// Descriptor returns a LibreOffice's module descriptor.
+func (LibreOffice) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "libreoffice",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("libreoffice", flag.ExitOnError)
+			fs.Bool("libreoffice-disable-routes", false, "Disable the routes")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(LibreOffice) },
+	}
+}
+
+// Provision sets the module properties.
+func (mod *LibreOffice) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	mod.disableRoutes = flags.MustBool("libreoffice-disable-routes")
+
+	provider, err := ctx.Module(new(unoconv.Provider))
+	if err != nil {
+		return fmt.Errorf("get unoconv provider: %w", err)
+	}
+
+	uno, err := provider.(unoconv.Provider).Unoconv()
+	if err != nil {
+		return fmt.Errorf("get unoconv API: %w", err)
+	}
+
+	mod.unoconv = uno
+
+	provider, err = ctx.Module(new(gotenberg.PDFEngineProvider))
+	if err != nil {
+		return fmt.Errorf("get PDF engine provider: %w", err)
+	}
+
+	engine, err := provider.(gotenberg.PDFEngineProvider).PDFEngine()
+	if err != nil {
+		return fmt.Errorf("get PDF engine: %w", err)
+	}
+
+	mod.engine = engine
+
+	return nil
+}
+
+// Routes returns the API routes.
+func (mod LibreOffice) Routes() ([]api.MultipartFormDataRoute, error) {
+	if mod.disableRoutes {
+		return nil, nil
+	}
+
+	return []api.MultipartFormDataRoute{
+		convertRoute(mod.unoconv, mod.engine),
+	}, nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module            = (*LibreOffice)(nil)
+	_ gotenberg.Provisioner       = (*LibreOffice)(nil)
+	_ api.MultipartFormDataRouter = (*LibreOffice)(nil)
+)

pkg/modules/libreoffice/libreoffice_test.go

@@ -0,0 +1,250 @@
+package libreoffice
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"go.uber.org/zap"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoUnoconvProvider struct {
+	ProtoModule
+	unoconv func() (unoconv.API, error)
+}
+
+func (mod ProtoUnoconvProvider) Unoconv() (unoconv.API, error) {
+	return mod.unoconv()
+}
+
+type ProtoUnoconvAPI struct {
+	pdf        func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error
+	extensions func() []string
+}
+
+func (mod ProtoUnoconvAPI) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error {
+	return mod.pdf(ctx, logger, inputPath, outputPath, options)
+}
+
+func (mod ProtoUnoconvAPI) Extensions() []string {
+	return mod.extensions()
+}
+
+type ProtoPDFEngineProvider struct {
+	ProtoModule
+	pdfEngine func() (gotenberg.PDFEngine, error)
+}
+
+func (mod ProtoPDFEngineProvider) PDFEngine() (gotenberg.PDFEngine, error) {
+	return mod.pdfEngine()
+}
+
+type ProtoPDFEngine struct {
+	merge   func(_ context.Context, _ *zap.Logger, _ []string, _ string) error
+	convert func(_ context.Context, _ *zap.Logger, _, _, _ string) error
+}
+
+func (mod ProtoPDFEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return mod.merge(ctx, logger, inputPaths, outputPath)
+}
+
+func (mod ProtoPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
+	return mod.convert(ctx, logger, format, inputPath, outputPath)
+}
+
+func TestLibreOffice_Descriptor(t *testing.T) {
+	descriptor := LibreOffice{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(LibreOffice))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestLibreOffice_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       *gotenberg.Context
+		expectErr bool
+	}{
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoModule }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(LibreOffice).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(LibreOffice).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return struct{ ProtoUnoconvAPI }{}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(LibreOffice).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod1 := struct{ ProtoUnoconvProvider }{}
+				mod1.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				}
+				mod1.unoconv = func() (unoconv.API, error) {
+					return struct{ ProtoUnoconvAPI }{}, nil
+				}
+
+				mod2 := struct{ ProtoPDFEngineProvider }{}
+				mod2.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
+				}
+				mod2.pdfEngine = func() (gotenberg.PDFEngine, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(LibreOffice).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod1.Descriptor(),
+						mod2.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod1 := struct{ ProtoUnoconvProvider }{}
+				mod1.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				}
+				mod1.unoconv = func() (unoconv.API, error) {
+					return struct{ ProtoUnoconvAPI }{}, nil
+				}
+
+				mod2 := struct{ ProtoPDFEngineProvider }{}
+				mod2.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
+				}
+				mod2.pdfEngine = func() (gotenberg.PDFEngine, error) {
+					return struct{ ProtoPDFEngine }{}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(LibreOffice).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod1.Descriptor(),
+						mod2.Descriptor(),
+					},
+				)
+			}(),
+		},
+	} {
+		mod := new(LibreOffice)
+		err := mod.Provision(tc.ctx)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestLibreOffice_Routes(t *testing.T) {
+	for i, tc := range []struct {
+		expectRoutes  int
+		disableRoutes bool
+	}{
+		{
+			expectRoutes: 1,
+		},
+		{
+			disableRoutes: true,
+		},
+	} {
+		mod := new(LibreOffice)
+		mod.disableRoutes = tc.disableRoutes
+
+		routes, err := mod.Routes()
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		if tc.expectRoutes != len(routes) {
+			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
+		}
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module            = (*ProtoModule)(nil)
+	_ unoconv.Provider            = (*ProtoUnoconvProvider)(nil)
+	_ gotenberg.Module            = (*ProtoUnoconvProvider)(nil)
+	_ unoconv.API                 = (*ProtoUnoconvAPI)(nil)
+	_ gotenberg.PDFEngineProvider = (*ProtoPDFEngineProvider)(nil)
+	_ gotenberg.Module            = (*ProtoPDFEngineProvider)(nil)
+	_ gotenberg.PDFEngine         = (*ProtoPDFEngine)(nil)
+)

pkg/modules/libreoffice/pdfengine/doc.go

@@ -0,0 +1,3 @@
+// Package pdfengine provides a module which abstracts the CLI tool unoconv and
+// implements the gotenberg.PDFEngine interface.
+package pdfengine

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -0,0 +1,76 @@
+package pdfengine
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"go.uber.org/zap"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(UnoconvPDFEngine{})
+}
+
+// UnoconvPDFEngine abstracts the CLI tool unoconv and implements the
+// gotenberg.PDFEngine interface.
+type UnoconvPDFEngine struct {
+	unoconv unoconv.API
+}
+
+// Descriptor returns a UnoconvPDFEngine's module descriptor.
+func (engine UnoconvPDFEngine) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID:  "unoconv-pdfengine",
+		New: func() gotenberg.Module { return new(UnoconvPDFEngine) },
+	}
+}
+
+// Provision sets the module properties.
+func (engine *UnoconvPDFEngine) Provision(ctx *gotenberg.Context) error {
+	provider, err := ctx.Module(new(unoconv.Provider))
+	if err != nil {
+		return fmt.Errorf("get unoconv provider: %w", err)
+	}
+
+	uno, err := provider.(unoconv.Provider).Unoconv()
+	if err != nil {
+		return fmt.Errorf("get unoconv API: %w", err)
+	}
+
+	engine.unoconv = uno
+
+	return nil
+}
+
+// Merge is not available for this PDF engine.
+func (engine UnoconvPDFEngine) Merge(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+	return fmt.Errorf("merge PDFs with unoconv: %w", gotenberg.ErrPDFEngineMethodNotAvailable)
+}
+
+// Convert converts the given PDF to a specific PDF format. Currently, only the
+// PDF/A-1 format is available. If another PDF format is requested, it returns
+// a gotenberg.ErrPDFFormatNotAvailable error.
+func (engine UnoconvPDFEngine) Convert(ctx context.Context, logger *zap.Logger, format, inputPath, outputPath string) error {
+	if format != gotenberg.FormatPDFA1a {
+		return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, gotenberg.ErrPDFFormatNotAvailable)
+	}
+
+	err := engine.unoconv.PDF(ctx, logger, inputPath, outputPath, unoconv.Options{
+		PDFArchive: true,
+	})
+
+	if err == nil {
+		return nil
+	}
+
+	return fmt.Errorf("convert PDF to '%s' with unoconv: %w", format, err)
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*UnoconvPDFEngine)(nil)
+	_ gotenberg.Provisioner = (*UnoconvPDFEngine)(nil)
+	_ gotenberg.PDFEngine   = (*UnoconvPDFEngine)(nil)
+)

pkg/modules/libreoffice/pdfengine/pdfengine_test.go

@@ -0,0 +1,197 @@
+package pdfengine
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/zap"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoUnoconvProvider struct {
+	ProtoModule
+	unoconv func() (unoconv.API, error)
+}
+
+func (mod ProtoUnoconvProvider) Unoconv() (unoconv.API, error) {
+	return mod.unoconv()
+}
+
+type ProtoUnoconvAPI struct {
+	pdf func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error
+}
+
+func (mod ProtoUnoconvAPI) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options unoconv.Options) error {
+	return mod.pdf(ctx, logger, inputPath, outputPath, options)
+}
+
+func (mod ProtoUnoconvAPI) Extensions() []string {
+	return nil
+}
+
+func TestUnoconvPDFEngine_Descriptor(t *testing.T) {
+	descriptor := UnoconvPDFEngine{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(UnoconvPDFEngine))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestUnoconvPDFEngine_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       *gotenberg.Context
+		expectErr bool
+	}{
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoModule }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoUnoconvProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.unoconv = func() (unoconv.API, error) {
+					return struct{ ProtoUnoconvAPI }{}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: flag.NewFlagSet("foo", flag.ExitOnError),
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+		},
+	} {
+		mod := new(UnoconvPDFEngine)
+		err := mod.Provision(tc.ctx)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestUnoconvPDFEngine_Merge(t *testing.T) {
+	mod := new(UnoconvPDFEngine)
+	err := mod.Merge(context.TODO(), zap.NewNop(), nil, "")
+
+	if !errors.Is(err, gotenberg.ErrPDFEngineMethodNotAvailable) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPDFEngineMethodNotAvailable, err)
+	}
+}
+
+func TestUnoconvPDFEngine_Convert(t *testing.T) {
+	for i, tc := range []struct {
+		api       unoconv.API
+		format    string
+		expectErr bool
+	}{
+		{
+			format:    "",
+			expectErr: true,
+		},
+		{
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
+					return errors.New("foo")
+				}
+
+				return unoconvAPI
+			}(),
+			format:    gotenberg.FormatPDFA1a,
+			expectErr: true,
+		},
+		{
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, __ string, _ unoconv.Options) error {
+					return nil
+				}
+
+				return unoconvAPI
+			}(),
+			format: gotenberg.FormatPDFA1a,
+		},
+	} {
+		mod := new(UnoconvPDFEngine)
+		mod.unoconv = tc.api
+
+		err := mod.Convert(context.TODO(), zap.NewNop(), tc.format, "", "")
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module = (*ProtoModule)(nil)
+	_ unoconv.Provider = (*ProtoUnoconvProvider)(nil)
+	_ gotenberg.Module = (*ProtoUnoconvProvider)(nil)
+	_ unoconv.API      = (*ProtoUnoconvAPI)(nil)
+)

pkg/modules/libreoffice/routes.go

@@ -0,0 +1,177 @@
+package libreoffice
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+)
+
+// convertRoute returns an api.MultipartFormDataRoute which can convert
+// LibreOffice documents to PDF.
+func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
+	return api.MultipartFormDataRoute{
+		Path: "/libreoffice/convert",
+		Handler: func(ctx *api.Context) error {
+			// Let's get the data from the form and validate them.
+			var (
+				inputPaths         []string
+				landscape          bool
+				nativePageRanges   string
+				nativePDFA1aFormat bool
+				PDFformat          string
+				merge              bool
+			)
+
+			err := ctx.FormData().
+				MandatoryPaths(uno.Extensions(), &inputPaths).
+				Bool("landscape", &landscape, false).
+				String("nativePageRanges", &nativePageRanges, "").
+				Bool("nativePdfA1aFormat", &nativePDFA1aFormat, false).
+				String("pdfFormat", &PDFformat, "").
+				Bool("merge", &merge, false).
+				Validate()
+
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			if nativePDFA1aFormat && PDFformat != "" {
+				return api.WrapError(
+					errors.New("got both 'pdfFormat' and 'nativePdfA1aFormat' form values"),
+					api.NewSentinelHTTPError(http.StatusBadRequest, "Both 'pdfFormat' and 'nativePdfA1aFormat' form values are provided"),
+				)
+			}
+
+			// Alright, let's convert each document to PDF.
+
+			outputPaths := make([]string, len(inputPaths))
+
+			for i, inputPath := range inputPaths {
+				outputPaths[i] = ctx.GeneratePath(".pdf")
+
+				options := unoconv.Options{
+					Landscape:  landscape,
+					PageRanges: nativePageRanges,
+					PDFArchive: nativePDFA1aFormat,
+				}
+
+				err = uno.PDF(ctx, ctx.Log(), inputPath, outputPaths[i], options)
+
+				if err != nil {
+					if errors.Is(err, unoconv.ErrMalformedPageRanges) {
+						return api.WrapError(
+							fmt.Errorf("convert to PDF: %w", err),
+							api.NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Malformed page ranges '%s' (nativePageRanges)", options.PageRanges)),
+						)
+					}
+
+					return fmt.Errorf("convert to PDF: %w", err)
+				}
+			}
+
+			// So far so good, let's check if we have to merge the PDFs. Quick
+			// win: if there is only one PDF, skip this step.
+
+			if len(outputPaths) > 1 && merge {
+				outputPath := ctx.GeneratePath(".pdf")
+
+				err = engine.Merge(ctx, ctx.Log(), outputPaths, outputPath)
+				if err != nil {
+					return fmt.Errorf("merge PDFs: %w", err)
+				}
+
+				// Now, let's check if the client want to convert this result
+				// PDF to a specific PDF format.
+
+				// Note: nativePdfA1aFormat has not been specified if we reach
+				// this part of the code. Indeed, the handler returns early on
+				// an error if both nativePdfA1aFormat and pdfFormat are
+				// present.
+
+				if PDFformat != "" {
+					convertInputPath := outputPath
+					convertOutputPath := ctx.GeneratePath(".pdf")
+
+					err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPath)
+
+					if err != nil {
+						if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+							return api.WrapError(
+								fmt.Errorf("convert PDF: %w", err),
+								api.NewSentinelHTTPError(
+									http.StatusBadRequest,
+									fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+								),
+							)
+						}
+
+						return fmt.Errorf("convert PDF: %w", err)
+					}
+
+					// Important: the output path is now the converted file.
+					outputPath = convertOutputPath
+				}
+
+				// 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)
+				if err != nil {
+					return fmt.Errorf("add output path: %w", err)
+				}
+
+				return nil
+			}
+
+			// Ok, we don't have to merge the PDFs. Let's check if the client
+			// want to convert each PDF to a specific PDF format.
+
+			// Note: nativePdfA1aFormat has not been specified if we reach this
+			// part of the code. Indeed, the handler returns early on an error
+			// if both nativePdfA1aFormat and pdfFormat are present.
+
+			if PDFformat != "" {
+				convertOutputPaths := make([]string, len(outputPaths))
+
+				for i, outputPath := range outputPaths {
+					convertInputPath := outputPath
+					convertOutputPaths[i] = ctx.GeneratePath(".pdf")
+
+					err = engine.Convert(ctx, ctx.Log(), PDFformat, convertInputPath, convertOutputPaths[i])
+
+					if err != nil {
+						if errors.Is(err, gotenberg.ErrPDFFormatNotAvailable) {
+							return api.WrapError(
+								fmt.Errorf("convert PDF: %w", err),
+								api.NewSentinelHTTPError(
+									http.StatusBadRequest,
+									fmt.Sprintf("At least one PDF engine does not handle the PDF format '%s' (pdfFormat), while other have failed to convert for other reasons", PDFformat),
+								),
+							)
+						}
+
+						return fmt.Errorf("convert PDF: %w", err)
+					}
+
+				}
+
+				// Important: the output paths are now the converted files.
+				outputPaths = convertOutputPaths
+			}
+
+			// 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...)
+			if err != nil {
+				return fmt.Errorf("add output paths: %w", err)
+			}
+
+			return nil
+		},
+	}
+}

pkg/modules/libreoffice/routes_test.go

@@ -0,0 +1,541 @@
+package libreoffice
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"go.uber.org/zap"
+)
+
+func TestConvertHandler(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                    *api.MockContext
+		api                    unoconv.API
+		engine                 gotenberg.PDFEngine
+		expectErr              bool
+		expectHTTPErr          bool
+		expectHTTPStatus       int
+		expectOutputPathsCount int
+	}{
+		{
+			ctx: &api.MockContext{Context: &api.Context{}},
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".foo",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"nativePdfA1aFormat": {
+						"true",
+					},
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return unoconv.ErrMalformedPageRanges
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return errors.New("foo")
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return errors.New("foo")
+					},
+				}
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return gotenberg.ErrPDFFormatNotAvailable
+					},
+				}
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return errors.New("foo")
+					},
+				}
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetCancelled(true)
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return nil
+					},
+				}
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return nil
+					},
+				}
+			}(),
+			expectOutputPathsCount: 1,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return gotenberg.ErrPDFFormatNotAvailable
+					},
+				}
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return errors.New("foo")
+					},
+				}
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetCancelled(true)
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return nil
+					},
+				}
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *api.MockContext {
+				ctx := &api.MockContext{Context: &api.Context{}}
+
+				ctx.SetFiles(map[string]string{
+					"foo.docx": "/foo/foo.docx",
+					"bar.docx": "/foo/bar.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"pdfFormat": {
+						"foo",
+					},
+				})
+
+				return ctx
+			}(),
+			api: func() unoconv.API {
+				unoconvAPI := struct{ ProtoUnoconvAPI }{}
+				unoconvAPI.pdf = func(_ context.Context, _ *zap.Logger, _, _ string, _ unoconv.Options) error {
+					return nil
+				}
+				unoconvAPI.extensions = func() []string {
+					return []string{
+						".docx",
+					}
+				}
+
+				return unoconvAPI
+			}(),
+			engine: func() gotenberg.PDFEngine {
+				return &ProtoPDFEngine{
+					merge: func(_ context.Context, _ *zap.Logger, _ []string, _ string) error {
+						return nil
+					},
+					convert: func(_ context.Context, _ *zap.Logger, _, _, _ string) error {
+						return nil
+					},
+				}
+			}(),
+			expectOutputPathsCount: 2,
+		},
+	} {
+		err := convertRoute(tc.api, tc.engine).Handler(tc.ctx.Context)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr api.HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+
+		if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+			t.Errorf("test %d: expected %d output paths but got %d", i, tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+		}
+	}
+}

pkg/modules/libreoffice/unoconv/doc.go

@@ -0,0 +1,2 @@
+// Package unoconv provides a module which abstracts the CLI tool unoconv.
+package unoconv

pkg/modules/libreoffice/unoconv/unoconv.go

@@ -0,0 +1,287 @@
+package unoconv
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"go.uber.org/zap"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(Unoconv{})
+}
+
+// ErrMalformedPageRanges happens if the page ranges option cannot be
+// interpreted by LibreOffice.
+var ErrMalformedPageRanges = errors.New("page ranges are malformed")
+
+// Unoconv is a module which provides an API to interact with unoconv.
+type Unoconv struct {
+	binPath string
+}
+
+// Options gathers available options when converting a document to PDF.
+type Options struct {
+	// Landscape allows to change the orientation of the resulting PDF.
+	// Optional.
+	Landscape bool
+
+	// PageRanges allows to select the pages to convert.
+	// TODO: should prefer a method form PDFEngine.
+	// Optional.
+	PageRanges string
+
+	// PDFArchive allows to convert the resulting PDF to PDF/A-1a.
+	// In a module, prefer the Convert method from the gotenberg.PDFEngine
+	// interface.
+	// Optional.
+	PDFArchive bool
+}
+
+// API is an abstraction on top of unoconv.
+//
+// See https://github.com/unoconv/unoconv.
+type API interface {
+	PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	Extensions() []string
+}
+
+// Provider is a module interface which exposes a method for creating an API
+// for other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(unoconv.Provider))
+//		uno, _      := provider.(unoconv.Provider).Unoconv()
+//	}
+type Provider interface {
+	Unoconv() (API, error)
+}
+
+// Descriptor returns a Unoconv's module descriptor.
+func (Unoconv) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID:  "unoconv",
+		New: func() gotenberg.Module { return new(Unoconv) },
+	}
+}
+
+// Provision sets the module properties. It returns an error if the environment
+// variable UNOCONV_BIN_PATH is not set.
+func (mod *Unoconv) Provision(_ *gotenberg.Context) error {
+	binPath, ok := os.LookupEnv("UNOCONV_BIN_PATH")
+	if !ok {
+		return errors.New("UNOCONV_BIN_PATH environment variable is not set")
+	}
+
+	mod.binPath = binPath
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (mod Unoconv) Validate() error {
+	_, err := os.Stat(mod.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("unoconv binary path does not exist: %w", err)
+	}
+
+	return nil
+}
+
+// Unoconv returns an API for interacting with unoconv.
+func (mod Unoconv) Unoconv() (API, error) {
+	return mod, nil
+}
+
+// PDF converts a document to PDF. It creates a dedicated LibreOffice instance
+// thanks to a custom user profile directory and a free port. Substantial calls
+// to this method may increase CPU and memory usage drastically. In such a
+// scenario, the given context may also be done before the end of the
+// conversion.
+func (mod Unoconv) PDF(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+	port, err := func() (int, error) {
+		listener, err := net.Listen("tcp", "127.0.0.1:0")
+		if err != nil {
+			return 0, fmt.Errorf("listen on the local network address: %w", err)
+		}
+		defer func() {
+			err := listener.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close listener: %s", err.Error()))
+			}
+		}()
+
+		addr := listener.Addr().String()
+
+		_, portStr, err := net.SplitHostPort(addr)
+		if err != nil {
+			return 0, fmt.Errorf("get free port from host: %w", err)
+		}
+
+		return strconv.Atoi(portStr)
+	}()
+
+	if err != nil {
+		return fmt.Errorf("get free port: %w", err)
+	}
+
+	userProfileDirPath := gotenberg.NewDirPath()
+
+	args := []string{
+		"--user-profile",
+		fmt.Sprintf("//%s", userProfileDirPath),
+		"--port",
+		fmt.Sprintf("%d", port),
+		"--format",
+		"pdf",
+	}
+
+	if options.Landscape {
+		args = append(args, "--printer", "PaperOrientation=landscape")
+	}
+
+	if options.PageRanges != "" {
+		args = append(args, "--export", fmt.Sprintf("PageRange=%s", options.PageRanges))
+	}
+
+	if options.PDFArchive {
+		args = append(args, "--export", "SelectPdfVersion=1")
+	}
+
+	args = append(args, "--output", outputPath, inputPath)
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, mod.binPath, args...)
+	if err != nil {
+		return fmt.Errorf("create unoconv command: %w", err)
+	}
+
+	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
+
+	err = cmd.Exec()
+
+	// Always remove the user profile directory created by LibreOffice.
+	// See https://github.com/thecodingmachine/gotenberg/issues/192.
+	go func() {
+		logger.Debug(fmt.Sprintf("remove user profile directory '%s'", userProfileDirPath))
+
+		err := os.RemoveAll(userProfileDirPath)
+		if err != nil {
+			logger.Error(fmt.Sprintf("remove user profile directory: %s", err))
+		}
+	}()
+
+	if err == nil {
+		return nil
+	}
+
+	// Unoconv/LibreOffice errors are not explicit.
+	// That's why we have to make an educated guess according to the exit code
+	// and given inputs.
+
+	if strings.Contains(err.Error(), "exit status 5") && options.PageRanges != "" {
+		return ErrMalformedPageRanges
+	}
+
+	// Possible errors:
+	// 1. Unoconv/LibreOffice failed for some reason.
+	// 2. Context done.
+	//
+	// On the second scenario, LibreOffice might not had time to remove some of
+	// its temporary files, as it has been killed without warning. The garbage
+	// collector will delete them for us (if the module is loaded).
+	return fmt.Errorf("unoconv PDF: %w", err)
+}
+
+// Extensions returns the file extensions available with unoconv.
+func (mod Unoconv) Extensions() []string {
+	return []string{
+		".bib",
+		".doc",
+		".xml",
+		".docx",
+		".fodt",
+		".html",
+		".ltx",
+		".txt",
+		".odt",
+		".ott",
+		".pdb",
+		".pdf",
+		".psw",
+		".rtf",
+		".sdw",
+		".stw",
+		".sxw",
+		".uot",
+		".vor",
+		".wps",
+		".epub",
+		".png",
+		".bmp",
+		".emf",
+		".eps",
+		".fodg",
+		".gif",
+		".jpg",
+		".met",
+		".odd",
+		".otg",
+		".pbm",
+		".pct",
+		".pgm",
+		".ppm",
+		".ras",
+		".std",
+		".svg",
+		".svm",
+		".swf",
+		".sxd",
+		".sxw",
+		".tiff",
+		".xhtml",
+		".xpm",
+		".fodp",
+		".potm",
+		".pot",
+		".pptx",
+		".pps",
+		".ppt",
+		".pwp",
+		".sda",
+		".sdd",
+		".sti",
+		".sxi",
+		".uop",
+		".wmf",
+		".csv",
+		".dbf",
+		".dif",
+		".fods",
+		".ods",
+		".ots",
+		".pxl",
+		".sdc",
+		".slk",
+		".stc",
+		".sxc",
+		".uos",
+		".xls",
+		".xlt",
+		".xlsx",
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*Unoconv)(nil)
+	_ gotenberg.Provisioner = (*Unoconv)(nil)
+	_ gotenberg.Validator   = (*Unoconv)(nil)
+	_ API                   = (*Unoconv)(nil)
+	_ Provider              = (*Unoconv)(nil)
+)

pkg/modules/libreoffice/unoconv/unoconv_test.go

@@ -0,0 +1,154 @@
+package unoconv
+
+import (
+	"context"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"go.uber.org/zap"
+)
+
+func TestUnoconv_Descriptor(t *testing.T) {
+	descriptor := Unoconv{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Unoconv))
+
+	if actual != expect {
+		t.Errorf("expected '%'s' but got '%s'", expect, actual)
+	}
+}
+
+func TestUnoconv_Provision(t *testing.T) {
+	mod := new(Unoconv)
+	ctx := gotenberg.NewContext(gotenberg.ParsedFlags{}, nil)
+
+	err := mod.Provision(ctx)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestUnoconv_Validate(t *testing.T) {
+	for i, tc := range []struct {
+		binPath   string
+		expectErr bool
+	}{
+		{
+			expectErr: true,
+		},
+		{
+			binPath:   "/foo",
+			expectErr: true,
+		},
+		{
+			binPath: os.Getenv("UNOCONV_BIN_PATH"),
+		},
+	} {
+		mod := new(Unoconv)
+		mod.binPath = tc.binPath
+		err := mod.Validate()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestUnoconv_Unoconv(t *testing.T) {
+	mod := new(Unoconv)
+
+	_, err := mod.Unoconv()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestUnoconv_PDF(t *testing.T) {
+	for i, tc := range []struct {
+		ctx       context.Context
+		inputPath string
+		options   Options
+		expectErr bool
+	}{
+		{
+			expectErr: true,
+		},
+		{
+			ctx:       context.Background(),
+			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
+			options: Options{
+				Landscape:  true,
+				PageRanges: "1-2",
+				PDFArchive: true,
+			},
+		},
+		{
+			ctx:       context.Background(),
+			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
+			options: Options{
+				PageRanges: "foo",
+			},
+			expectErr: true,
+		},
+		{
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.TODO())
+				defer cancel()
+
+				return ctx
+			}(),
+			inputPath: "/tests/test/testdata/libreoffice/sample1.docx",
+			expectErr: true,
+		},
+	} {
+		func() {
+			mod := new(Unoconv)
+
+			err := mod.Provision(nil)
+			if err != nil {
+				t.Fatalf("test %d: expected error but got: %v", i, err)
+			}
+
+			outputDir, err := gotenberg.MkdirAll()
+			if err != nil {
+				t.Fatalf("test %d: expected error but got: %v", i, err)
+			}
+
+			defer func() {
+				err := os.RemoveAll(outputDir)
+				if err != nil {
+					t.Fatalf("test %d: expected no error but got: %v", i, err)
+				}
+			}()
+
+			err = mod.PDF(tc.ctx, zap.NewNop(), tc.inputPath, outputDir+"/foo.pdf", tc.options)
+
+			if tc.expectErr && err == nil {
+				t.Errorf("test %d: expected error but got: %v", i, err)
+			}
+
+			if !tc.expectErr && err != nil {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+		}()
+	}
+}
+
+func TestUnoconv_Extensions(t *testing.T) {
+	mod := new(Unoconv)
+	extensions := mod.Extensions()
+
+	actual := len(extensions)
+	expect := 73
+
+	if actual != expect {
+		t.Errorf("expected %d extentions but got %d", expect, actual)
+	}
+}