chore(deps): update Go dependencies

* Fix auto-restart's initial number of requests
It would need 1 less requests on the first restart
The number of request was technically off by one after the first restart

* Supervisor now eagerly restarts processes
When the maxReqLimit is reached, restart the process in the background

* Update pkg/gotenberg/supervisor.go

Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com>

---------

Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com>

.blueprints/Dockerfile.blueprint

@@ -1,64 +0,0 @@
-FROM {{ if eq "CI" .Orbit.Image }}golang:1.10-stretch{{ else }}debian:stretch-slim{{ end }}
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-{{- if eq "CI" .Orbit.Image }}
-
-WORKDIR /go/src/github.com/thecodingmachine/gotenberg
-
-# Installs lint dependencies.
-RUN go get -u gopkg.in/alecthomas/gometalinter.v2 &&\
-    gometalinter.v2 --install
-
-# Copies our Go source.
-COPY . .
-
-# Installs project dependencies.
-RUN go get -d -v ./...
-
-ENTRYPOINT [".ci/docker-entrypoint.sh"]
-{{- else }}
-
-COPY .ci/gotenberg /usr/bin/gotenberg
-RUN ln -s /usr/bin/gotenberg /usr/local/bin/gotenberg
-
-COPY .ci/gotenberg.yml /gotenberg/gotenberg.yml
-
-WORKDIR /gotenberg
-
-EXPOSE 3000
-CMD ["gotenberg"]
-{{- end }}

.blueprints/README.blueprint.md

@@ -1,136 +0,0 @@
-<p align="center">
-    <img src="https://user-images.githubusercontent.com/8983173/38133342-11df3bd8-340f-11e8-9fe4-50baecdceeca.png" alt="Gotenberg's logo" width="250" height="250" />
-</p>
-<h3 align="center">Gotenberg</h3>
-<p align="center">A stateless API for converting Markdown files, HTML files and Office documents to PDF</p>
-<p align="center">
-    <a href="https://microbadger.com/images/thecodingmachine/gotenberg:{{ .Orbit.Latest }}">
-        <img src="https://images.microbadger.com/badges/image/thecodingmachine/gotenberg:{{ .Orbit.Latest }}.svg" alt="MicroBadger layers">
-    </a>
-    <a href="https://travis-ci.org/thecodingmachine/gotenberg">
-        <img src="https://travis-ci.org/thecodingmachine/gotenberg.svg?branch={{ .Orbit.Branch }}" alt="Travis CI">
-    </a>
-    <a href="https://godoc.org/github.com/thecodingmachine/gotenberg">
-        <img src="https://godoc.org/github.com/thecodingmachine/gotenberg?status.svg" alt="GoDoc">
-    </a>
-    <a href="https://goreportcard.com/report/thecodingmachine/gotenberg">
-        <img src="https://goreportcard.com/badge/github.com/thecodingmachine/gotenberg" alt="Go Report Card">
-    </a>
-    <a href="https://codecov.io/gh/thecodingmachine/gotenberg/branch/{{ .Orbit.Branch }}">
-        <img src="https://codecov.io/gh/thecodingmachine/gotenberg/branch/{{ .Orbit.Branch }}/graph/badge.svg" alt="Codecov">
-    </a>
-</p>
-
----
-
-At TheCodingMachine, we build a lot of web applications (intranets, extranets and so on) which require to generate PDF from 
-various sources. Each time, we ended up using some well known libraries like **wkhtmltopdf** or **unoconv** and kind of lost time by
-reimplementing a solution from a project to another project. Meh.
-
-# Menu
-
-* [Usage](#usage)
-* [Security](#security)
-* [Scalability](#scalability)
-* [Custom implementation](#custom-implementation)
-* [Clients](#clients)
-
-## Usage
-
-Let's say you're starting the API using this simple command:
-
-```sh
-$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:{{ .Orbit.Latest }}
-```
-
-The API is now available on your host under `http://127.0.0.1:3000`.
-
-It accepts `POST` requests with a `multipart/form-data` Content-Type. Your form data should provide one or more files to convert.
-It currently accepts the following:
-
-* Markdown files
-* HTML files
-* Office documents (.docx, .doc, .odt, .pptx, .ppt, .odp and so on)
-* PDF files (if more than one file to convert)
-
-**Heads up:** the API relies on the file extension to determine which library to use for conversion.
-
-There are two use cases:
-
-* If you send one file, it will convert it and return the resulting PDF
-* If many files, it will convert them to PDF, merge the resulting PDFs into a single PDF and return it
-
-### Examples:
-
-* One file
-
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.docx \
-    > result.pdf
-```
-
-* Many files
-
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.md \
-    --form files=@file.html \
-    --form files=@file.pdf \
-    --form files=@file.docx \
-    > result.pdf
-```
-
-## Security
-
-The API does not provide any authentication mechanisms. Make sure to not put it on a public facing port and your client(s) should always 
-controls what is sent to the API.
-
-## Scalability
-
-Some libraries like **unoconv** cannot perform concurrent conversions. That's why the API does only one conversion at a time.
-If your API is under heavy load, a request will take time to be processed. 
-
-Fortunately, you may pass through this limitation by scaling the API.
-
-In the following example, I'll demonstrate how to do some vertical scaling (= on the same machine) with Docker Compose, but of course horizontal scaling works too!
-
-```yaml
-version: '3'
-
-services:
-
-  # your others services
-      
-  gotenberg:
-    image: gotenberg:1.0.0
-```
-
-You may now launch your services using:
-
-```bash
-docker-compose up --scale gotenberg=your_number_of_instances
-```
-
-When requesting the Gotenberg service with your client(s), Docker will automatically redirect a request to a Gotenberg container
-according to the round-robin strategy.
-
-## Custom implementation
-
-The API relies on a simple YAML configuration file called `gotenberg.yml`. It allows you to tweak some values and even provides you 
-a way to change the commands called for each kind of conversion. The configuration file should be located under `/gotenberg` in your container.
-
-The default configuration is located here: [.ci/gotenberg.yml](.ci/gotenberg.yml)
-
-## Clients
-
-* https://github.com/thecodingmachine/gotenberg-php-client (PHP client)
-* Add your own client by submitting a [pull request](../../pulls)!
-
----
-
-Would you like to update this documentation ? Feel free to open an [issue](../../issues).

.ci/docker-entrypoint.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-
-set -xe
-
-# Statically checking Go source for errors and warnings.
-gometalinter.v2 --disable-all -E vet -E gofmt -E misspell -E ineffassign -E goimports -E deadcode -E gocyclo --vendor ./...;
-
-# Running tests according to current Gotenberg version.
-if [[ "$VERSION" == "snapshot" ]]; then
-    for d in $(go list ./... | grep -v vendor); do
-        go test -race -cover -covermode=atomic $d;
-    done
-else
-    echo "" > .ci/coverage.txt;
-    for d in $(go list ./... | grep -v vendor); do
-        go test -race -coverprofile=profile.out -covermode=atomic $d;
-        if [ -f profile.out ]; then
-            cat profile.out >> .ci/coverage.txt;
-            rm profile.out;
-        fi
-    done
-fi
-
-
-# Builds the Linux binary.
-if [ -f .ci/gotenberg ]; then
-    rm .ci/gotenberg
-fi
-
-env GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION}" && mv gotenberg .ci/;
-
-# Bye!
-exit 0;

.ci/gotenberg.yml

@@ -1,33 +0,0 @@
-# The port the application will listen to.
-port: 3000
-
-logs:
-  # Accepted values, in order of severity: DEBUG, INFO, WARN, ERROR, FATAL, PANIC.
-  # Messages at and above the selected level will be logged.
-  level: "INFO"
-
-  # Accepted values: text, json.
-  # When a TTY is not attached, the output will be in the defined format.
-  format: "text"
-
-# You don't like a library which is used for a conversion? You may provide here your own implementation.
-commands:
-
-  markdown:
-    # Duration in seconds after which the command will be killed if it has not finished.
-    timeout: 30
-    # The command template: you have access to FilePath and ResultFilePath variables.
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-
-  merge:
-    timeout: 30
-    # Unlike others commands' templates, you have access to FilesPaths instead of FilePath: it gathers all PDF files which should be merged.
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

.dockerignore

@@ -0,0 +1 @@
+.git

.github/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at neuhart.julien@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -1,33 +0,0 @@
-# Contributing
-
-Hi! Thank your for considering contributing to Gotenberg. You'll
-find below useful information about how to contribute to the Gotenberg project.
-
-## Contributing code
-
-### Install from sources
-
-1. Fork this repository
-2. Clone it to your local Go environment (requires *Go* >= 1.10)
-3. Install the latest [Orbit](https://github.com/gulien/orbit) release
-
-### Working with git
-
-1. Create your feature branch (`git checkout -b my-new-feature`)
-2. Commit your changes (`git commit -am 'Add some feature'`)
-3. Push to the branch (`git push origin my-new-feature`)
-4. Create a new pull request
-
-## Reporting bugs and feature request
-
-Your issue or feature request may already be reported!
-Please search on the [issue tracker](../../../issues) before creating one.
-
-If you do not find any relevant issue or feature request, feel free to
-add a new one!
-
-## Additional resources
-
-* [Code of conduct](CODE_OF_CONDUCT.md)
-* [Issue template](ISSUE_TEMPLATE.md)
-* [Pull request template](PULL_REQUEST_TEMPLATE.md)

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [gulien]

.github/ISSUE_TEMPLATE.md

@@ -1,32 +0,0 @@
-Your issue may already be reported!
-Please search on the [issue tracker](../../../issues) before creating one.
-
-## Expected Behavior
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
-
-## Current Behavior
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-## Possible Solution
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
-<!--- or ideas how to implement the addition or change -->
-
-## Steps to Reproduce (for bugs)
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-1.
-2.
-3.
-4.
-
-## Context
-<!--- How has this issue affected you? What are you trying to accomplish? -->
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
-
-## Your Environment
-<!--- Include as many relevant details about the environment you experienced the bug in -->
-* Version used:
-* Operating System and version:
-* Link to your project:

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,44 +0,0 @@
-A similar PR may already be submitted!
-Please search among the [pull requests](../../../pulls) before creating one.
-
-Thanks for submitting a pull request! Please provide enough information so that others can review your pull request:
-
-For more information, see the [CONTRIBUTING](CONTRIBUTING.md) guide.
-
-**Summary**
-
-<!-- Summary of the PR -->
-
-This PR fixes/implements the following **bugs/features**
-
-* [ ] Bug 1
-* [ ] Bug 2
-* [ ] Feature 1
-* [ ] Feature 2
-* [ ] Breaking changes
-
-<!-- You can skip this if you're fixing a typo or adding an app to the Showcase. -->
-
-Explain the **motivation** for making this change. What existing problem does the pull request solve?
-
-<!-- Example: When "Adding a function to do X", explain why it is necessary to have a way to do X. -->
-
-**Test plan (required)**
-
-Demonstrate the code is solid. Example: The exact commands you ran and their output.
-
-<!-- Make sure tests pass on both Travis and AppVeyor. -->
-
-**Closing issues**
-
-<!-- Put `closes #XXXX` in your comment to auto-close the issue that your PR fixes (if such). -->
-Fixes #
-
-**Checklist**
-
-- [ ] Have you followed the guidelines in our [CONTRIBUTING](CONTRIBUTING.md) guide?
-- [ ] Have you lint your code locally prior to submission (`orbit run fmt`)?
-- [ ] Have you written new tests for your core changes, as applicable?
-- [ ] Have you successfully ran tests with your changes locally (`orbit run ci`)?
-- [ ] I have squashed any insignificant commits
-- [ ] This change has comments for package types, values, functions, and non-obvious lines of code

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/stale.yml

@@ -0,0 +1,18 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 7
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 3
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - bug
+  - documentation
+  - enhancement
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.github/workflows/continuous_delivery.yml

@@ -0,0 +1,26 @@
+name: Continuous Delivery
+
+on:
+  release:
+    types: [ published ]
+
+jobs:
+  release:
+    name: Release Docker image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push Docker image for release
+        run: |
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }}
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REGISTRY=thecodingmachine

.github/workflows/continuous_integration.yml

@@ -0,0 +1,95 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache: false
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Run linters
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.60.3
+
+  tests:
+    needs:
+      - lint
+    name: Tests
+    # TODO: once arm64 actions are available, also run the tests on this architecture.
+    # See: https://github.com/actions/virtual-environments/issues/2552#issuecomment-771478000.
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Build testing environment
+        run: make build build-tests
+      - name: Run tests
+        run: make tests-once
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true
+
+  snapshot_release:
+    if: github.event_name == 'pull_request'
+    needs:
+      - tests
+    name: Snapshot release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push snapshot Docker image (linux/amd64)
+        run: make release GOTENBERG_VERSION=${{ github.head_ref }} DOCKER_REPOSITORY=snapshot LINUX_AMD64_RELEASE=true
+
+  edge_release:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs:
+      - tests
+    name: Edge release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push Docker image for main branch
+        run: |
+          make release GOTENBERG_VERSION=edge
+          make release GOTENBERG_VERSION=edge DOCKER_REGISTRY=thecodingmachine

.gitignore

@@ -1,2 +1,5 @@
-.ci/coverage.txt
-.ci/gotenberg
+/coverage.html
+/coverage.txt
+.idea
+.vscode
+.DS_Store

.golangci.yml

@@ -0,0 +1,60 @@
+linters-settings:
+  gci:
+    sections:
+      - standard
+      - default
+      - prefix(github.com/gotenberg/gotenberg/v8)
+    skip-generated: true
+    custom-order: true
+  # Until https://github.com/securego/gosec/issues/1187 is resolved.
+  gosec:
+    excludes:
+      - G115
+
+linters:
+  disable-all: true
+  enable:
+    - asasalint
+    - asciicheck
+    - bidichk
+    - bodyclose
+    - decorder
+    - dogsled
+    - dupl
+    - dupword
+    - durationcheck
+    - copyloopvar
+    - errcheck
+    - errname
+    - exhaustive
+    - gci
+    - gofmt
+    - goimports
+    - gofumpt
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - importas
+    - misspell
+    - prealloc
+    - promlinter
+    #- sloglint
+    - staticcheck
+    - tenv
+    - testableexamples
+    - tparallel
+    - typecheck
+    - unconvert
+    - unused
+    - wastedassign
+    - whitespace
+
+run:
+  timeout: 5m
+  issues-exit-code: 1
+  tests: false
+
+output:
+  print-issued-lines: true
+  print-linter-name: true

.travis.yml

@@ -1,23 +0,0 @@
-sudo: required
-
-language: generic
-
-services:
-  - docker
-
-env:
-  global:
-  - secure: d6pliM7iR7KJ3TQkr1C0tHi0HgU6Vdmc/ycw11XrXs794/dgj6g9UDrhgcvT2mTzOVIUNouHx7gyEWAlwJv7p8PPyguHJfIsyqMWfaXNPoytTx1ETUiygl1G/UsvXVdry6I5tZF/U+/PJ3hBXoAvo8EOFe0/MxxvP3ghCeeCpeEwEdoYP2jbADGffywVUNI7OEdmS29A28GusXXp2cWCIZYSq5Gn5iu1ZMPaJA6SkRTXpS+iVVLUvlbz5HW09ETFfurTvsdz5Ze4JICiuQt///CR1uwdxD8K7Ils/mkenaMtja9NHA9RdQBa51Azn8iCLsObCTYc52Zb6atbCi/X4ae9M8GA8qaaLigNz5G4v1BHneJylYfWKj5GwqUA3VmRu1mlEw7d2sN2uFRmgIl5kgsYYyOVOLBOKaJWhyBhNnR4U8KeqwUkOnlSdmNZnjfexXXBEcKHen1SozpXwMnzZh8LZuN6BNYd6TVpKmjulGI3vqNMM0c4JJZ9pSm4q5FjbNGQArwCsujDDwY4bCGZSJJTPMXjYOrx4yJ1RY+0TpyV9oDU3ogEqaWnhrkgrphfiYBlDY2bEvrxMTMukLCxJb0Nru6LGCpg4X1P9hu9r0gceqUSnBgdJI4rYTNddenxlEd4j/Thqv835stJWz6YoV+rfvERuSUpntl8xvrk3U8=
-  - secure: CmLh169xwt3OC7l19lDUwdZYfw+l/+XXKjTGxnuJiXHa9hAH+nc4mEUSmqHMHwjquyYE6LnSVGZ94LH8sCaGed/TMm0Lj3DZtZ0VsjYu3sKsNrVJn5WdYEah+GvNJ8i8uzvHnGk1L2fAagLpXFUB2K9UraA1CFiHs1fF5Fua7Ra0mE7lMz0MFvyvzcmc9u8nMz71K2YVsXqn+I/rv8onJCTtc/Ds0hVrBXwG5Fh0T3xHqjOhME9ZI2hRHnnQVdBojSY3USifQ//qAKowfBVc0pebEtgFpyXx/I17A6xCm0KVtnA2tNqu1+XFkjWaBzryaLE9ujhJcTRC/YK0JUZ+QxfYbD5C7jVy9Jlx1lOEjJ42B/ImNxPP+9p3wi2MWNbcbZJPxIe635fnT17lI7CLK2Qg1xjfTQ4WTEKW5IhnYMiyfRKiripFh4PCkDm8cJlTbpntsX1n0uheydbsgf/11vS7o1WGhVQ8+Jelc4DvIbBHCqienQEOLJDBwm7FiK5JbwZJ6ZAGeDM/IhGU1h9PNjVbHUyJhUxYoPYUE9QsZFT7ENCrRQpq49KOzXBRfffyJNJRh+Ep9X5YoW0dUp0MNu5B7z2+6w9X9n/C+loa11xF42bFzniCvvbSOQ37J+EngDinVxJkNPeyivR4fye2ENhIAjAEjouTJLOSXL9nAOU=
-
-before_install:
-  - wget -qO- https://github.com/gulien/orbit/releases/download/v3.0.0/orbit_Linux_x86_64.tar.gz | tar xvz -C .
-  - sudo mv ./orbit /usr/local/bin && chmod +x /usr/local/bin/orbit
-
-script:
-  - orbit run ci -p "Version,${TRAVIS_BRANCH}"
-  - orbit run build -p "Version,${TRAVIS_BRANCH}"
-  # Uploads coverage.
-  - bash <(curl -s https://codecov.io/bash)
-  # Let's push to Docker hub only if not in a pull request and the branch name matches the semver format.
-  - if [[ "$TRAVIS_PULL_REQUEST" = false && "$TRAVIS_BRANCH" =~ ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$ ]]; then docker login -u $DOCKER_USER -p $DOCKER_PASS && docker push thecodingmachine/gotenberg:${TRAVIS_BRANCH}; fi

Dockerfile

@@ -1,46 +0,0 @@
-FROM debian:stretch-slim
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-COPY .ci/gotenberg /usr/bin/gotenberg
-RUN ln -s /usr/bin/gotenberg /usr/local/bin/gotenberg
-
-COPY .ci/gotenberg.yml /gotenberg/gotenberg.yml
-
-WORKDIR /gotenberg
-
-EXPOSE 3000
-CMD ["gotenberg"]

Dockerfile.ci

@@ -1,50 +0,0 @@
-FROM golang:1.10-stretch
-
-LABEL authors="Julien Neuhart <j.neuhart@thecodingmachine.com>"
-
-# |--------------------------------------------------------------------------
-# | Libraries
-# |--------------------------------------------------------------------------
-# |
-# | Installs all required libraries.
-# |
-
-RUN echo "deb http://httpredir.debian.org/debian/ stretch main contrib non-free" > /etc/apt/sources.list &&\
-    apt-get update &&\
-    apt-get install -y xvfb wkhtmltopdf pdftk unoconv ttf-mscorefonts-installer &&\
-    ln -s /usr/bin/xvfb-run /usr/local/bin/xvfb-run &&\
-    ln -s /usr/bin/wkhtmltopdf /usr/local/bin/wkhtmltopdf &&\
-    ln -s /usr/bin/pdftk /usr/local/bin/pdftk &&\
-    ln -s /usr/bin/unoconv /usr/local/bin/unoconv
-
-RUN apt-get install -y curl gnupg &&\
-    curl -sL https://deb.nodesource.com/setup_8.x | bash - &&\
-    apt-get update &&\
-    apt-get install -y nodejs
-
-RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
-    echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
-    apt-get update &&\
-    apt-get install -y yarn bzip2 &&\
-    yarn global add markdown-pdf --prefix /usr/local
-
-# |--------------------------------------------------------------------------
-# | Gotenberg
-# |--------------------------------------------------------------------------
-# |
-# | All Gotenberg related stuff.
-# |
-
-WORKDIR /go/src/github.com/thecodingmachine/gotenberg
-
-# Installs lint dependencies.
-RUN go get -u gopkg.in/alecthomas/gometalinter.v2 &&\
-    gometalinter.v2 --install
-
-# Copies our Go source.
-COPY . .
-
-# Installs project dependencies.
-RUN go get -d -v ./...
-
-ENTRYPOINT [".ci/docker-entrypoint.sh"]

Gopkg.lock

@@ -1,60 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  name = "github.com/gorilla/context"
-  packages = ["."]
-  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
-  version = "v1.1"
-
-[[projects]]
-  name = "github.com/gorilla/mux"
-  packages = ["."]
-  revision = "53c1911da2b537f792e7cafcb446b05ffe33b996"
-  version = "v1.6.1"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/justinas/alice"
-  packages = ["."]
-  revision = "03f45bd4b7dad4734bc4620e46a35789349abb20"
-
-[[projects]]
-  name = "github.com/satori/go.uuid"
-  packages = ["."]
-  revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
-  version = "v1.2.0"
-
-[[projects]]
-  name = "github.com/sirupsen/logrus"
-  packages = ["."]
-  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
-  version = "v1.0.5"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-  packages = ["ssh/terminal"]
-  revision = "88942b9c40a4c9d203b82b3731787b672d6e809b"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = [
-    "unix",
-    "windows"
-  ]
-  revision = "13d03a9a82fba647c21a0ef8fba44a795d0f0835"
-
-[[projects]]
-  name = "gopkg.in/yaml.v2"
-  packages = ["."]
-  revision = "86f5ed62f8a0ee96bd888d2efdfd6d4fb100a4eb"
-  version = "v2.2.0"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "9d7a607d9b015e46c535126cbc62648ce78459507cd523d6ff0e048051cf3228"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,50 +0,0 @@
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#   name = "github.com/x/y"
-#   version = "2.4.0"
-#
-# [prune]
-#   non-go = false
-#   go-tests = true
-#   unused-packages = true
-
-
-[prune]
-  go-tests = true
-  unused-packages = true
-
-[[constraint]]
-  name = "github.com/satori/go.uuid"
-  version = "1.2.0"
-
-[[constraint]]
-  name = "github.com/gorilla/mux"
-  version = "1.6.1"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/justinas/alice"
-
-[[constraint]]
-  name = "gopkg.in/yaml.v2"
-  version = "2.2.0"
-
-[[constraint]]
-  name = "github.com/sirupsen/logrus"
-  version = "1.0.5"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 TheCodingMachine
+Copyright (c) 2024 Julien Neuhart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,201 @@
+.PHONY: help
+help: ## Show the help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: it
+it: build build-tests ## Initialize the development environment
+
+GOLANG_VERSION=1.23
+DOCKER_REGISTRY=gotenberg
+DOCKER_REPOSITORY=gotenberg
+GOTENBERG_VERSION=snapshot
+GOTENBERG_USER_GID=1001
+GOTENBERG_USER_UID=1001
+NOTO_COLOR_EMOJI_VERSION=v2.042 # See https://github.com/googlefonts/noto-emoji/releases.
+PDFTK_VERSION=v3.3.3 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
+GOLANGCI_LINT_VERSION=v1.60.3 # See https://github.com/golangci/golangci-lint/releases.
+
+.PHONY: build
+build: ## Build the Gotenberg's Docker image
+	docker build \
+	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
+	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
+	--build-arg GOTENBERG_USER_GID=$(GOTENBERG_USER_GID) \
+	--build-arg GOTENBERG_USER_UID=$(GOTENBERG_USER_UID) \
+	--build-arg NOTO_COLOR_EMOJI_VERSION=$(NOTO_COLOR_EMOJI_VERSION) \
+	--build-arg PDFTK_VERSION=$(PDFTK_VERSION) \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
+	-f build/Dockerfile .
+
+GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
+API_PORT=3000
+API_PORT_FROM_ENV=
+API_START_TIMEOUT=30s
+API_TIMEOUT=30s
+API_ROOT_PATH=/
+API_TRACE_HEADER=Gotenberg-Trace
+API_ENABLE_BASIC_AUTH=false
+GOTENBERG_API_BASIC_AUTH_USERNAME=
+GOTENBERG_API_BASIC_AUTH_PASSWORD=
+API-DOWNLOAD-FROM-ALLOW-LIST=
+API-DOWNLOAD-FROM-DENY-LIST=
+API-DOWNLOAD-FROM-FROM-MAX-RETRY=4
+API-DISABLE-DOWNLOAD-FROM=false
+API_DISABLE_HEALTH_CHECK_LOGGING=false
+CHROMIUM_RESTART_AFTER=0
+CHROMIUM_MAX_QUEUE_SIZE=0
+CHROMIUM_AUTO_START=false
+CHROMIUM_START_TIMEOUT=20s
+CHROMIUM_INCOGNITO=false
+CHROMIUM_ALLOW_INSECURE_LOCALHOST=false
+CHROMIUM_IGNORE_CERTIFICATE_ERRORS=false
+CHROMIUM_DISABLE_WEB_SECURITY=false
+CHROMIUM_ALLOW_FILE_ACCESS_FROM_FILES=false
+CHROMIUM_HOST_RESOLVER_RULES=
+CHROMIUM_PROXY_SERVER=
+CHROMIUM_ALLOW_LIST=
+CHROMIUM_DENY_LIST=^file:(?!//\/tmp/).*
+CHROMIUM_CLEAR_CACHE=false
+CHROMIUM_CLEAR_COOKIES=false
+CHROMIUM_DISABLE_JAVASCRIPT=false
+CHROMIUM_DISABLE_ROUTES=false
+LIBREOFFICE_RESTART_AFTER=10
+LIBREOFFICE_MAX_QUEUE_SIZE=0
+LIBREOFFICE_AUTO_START=false
+LIBREOFFICE_START_TIMEOUT=20s
+LIBREOFFICE_DISABLE_ROUTES=false
+LOG_LEVEL=info
+LOG_FORMAT=auto
+LOG_FIELDS_PREFIX=
+PDFENGINES_ENGINES=
+PDFENGINES_DISABLE_ROUTES=false
+PROMETHEUS_NAMESPACE=gotenberg
+PROMETHEUS_COLLECT_INTERVAL=1s
+PROMETHEUS_DISABLE_ROUTE_LOGGING=false
+PROMETHEUS_DISABLE_COLLECT=false
+WEBHOOK_ALLOW_LIST=
+WEBHOOK_DENY_LIST=
+WEBHOOK_ERROR_ALLOW_LIST=
+WEBHOOK_ERROR_DENY_LIST=
+WEBHOOK_MAX_RETRY=4
+WEBHOOK_RETRY_MIN_WAIT=1s
+WEBHOOK_RETRY_MAX_WAIT=30s
+WEBHOOK_CLIENT_TIMEOUT=30s
+WEBHOOK_DISABLE=false
+
+.PHONY: run
+run: ## Start a Gotenberg container
+	docker run --rm -it \
+	-p $(API_PORT):$(API_PORT) \
+	-e GOTENBERG_API_BASIC_AUTH_USERNAME=$(GOTENBERG_API_BASIC_AUTH_USERNAME) \
+	-e GOTENBERG_API_BASIC_AUTH_PASSWORD=$(GOTENBERG_API_BASIC_AUTH_PASSWORD) \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
+	gotenberg \
+	--gotenberg-graceful-shutdown-duration=$(GOTENBERG_GRACEFUL_SHUTDOWN_DURATION) \
+	--api-port=$(API_PORT) \
+	--api-port-from-env=$(API_PORT_FROM_ENV) \
+	--api-start-timeout=$(API_START_TIMEOUT) \
+	--api-timeout=$(API_TIMEOUT) \
+	--api-root-path=$(API_ROOT_PATH) \
+	--api-trace-header=$(API_TRACE_HEADER) \
+	--api-enable-basic-auth=$(API_ENABLE_BASIC_AUTH) \
+	--api-download-from-allow-list=$(API-DOWNLOAD-FROM-ALLOW-LIST) \
+    --api-download-from-deny-list=$(API-DOWNLOAD-FROM-DENY-LIST) \
+    --api-download-from-max-retry=$(API-DOWNLOAD-FROM-FROM-MAX-RETRY) \
+    --api-disable-download-from=$(API-DISABLE-DOWNLOAD-FROM) \
+	--api-disable-health-check-logging=$(API_DISABLE_HEALTH_CHECK_LOGGING) \
+	--chromium-restart-after=$(CHROMIUM_RESTART_AFTER) \
+	--chromium-auto-start=$(CHROMIUM_AUTO_START) \
+	--chromium-max-queue-size=$(CHROMIUM_MAX_QUEUE_SIZE) \
+	--chromium-start-timeout=$(CHROMIUM_START_TIMEOUT) \
+	--chromium-incognito=$(CHROMIUM_INCOGNITO) \
+	--chromium-allow-insecure-localhost=$(CHROMIUM_ALLOW_INSECURE_LOCALHOST) \
+	--chromium-ignore-certificate-errors=$(CHROMIUM_IGNORE_CERTIFICATE_ERRORS) \
+	--chromium-disable-web-security=$(CHROMIUM_DISABLE_WEB_SECURITY) \
+	--chromium-allow-file-access-from-files=$(CHROMIUM_ALLOW_FILE_ACCESS_FROM_FILES) \
+	--chromium-host-resolver-rules=$(CHROMIUM_HOST_RESOLVER_RULES) \
+	--chromium-proxy-server=$(CHROMIUM_PROXY_SERVER) \
+	--chromium-allow-list="$(CHROMIUM_ALLOW_LIST)" \
+	--chromium-deny-list="$(CHROMIUM_DENY_LIST)" \
+	--chromium-clear-cache=$(CHROMIUM_CLEAR_CACHE) \
+	--chromium-clear-cookies=$(CHROMIUM_CLEAR_COOKIES) \
+	--chromium-disable-javascript=$(CHROMIUM_DISABLE_JAVASCRIPT) \
+	--chromium-disable-routes=$(CHROMIUM_DISABLE_ROUTES) \
+	--libreoffice-restart-after=$(LIBREOFFICE_RESTART_AFTER) \
+	--libreoffice-max-queue-size=$(LIBREOFFICE_MAX_QUEUE_SIZE) \
+	--libreoffice-auto-start=$(LIBREOFFICE_AUTO_START) \
+	--libreoffice-start-timeout=$(LIBREOFFICE_START_TIMEOUT) \
+	--libreoffice-disable-routes=$(LIBREOFFICE_DISABLE_ROUTES) \
+	--log-level=$(LOG_LEVEL) \
+	--log-format=$(LOG_FORMAT) \
+	--log-fields-prefix=$(LOG_FIELDS_PREFIX) \
+	--pdfengines-engines=$(PDFENGINES_ENGINES) \
+	--pdfengines-disable-routes=$(PDFENGINES_DISABLE_ROUTES) \
+	--prometheus-namespace=$(PROMETHEUS_NAMESPACE) \
+	--prometheus-collect-interval=$(PROMETHEUS_COLLECT_INTERVAL) \
+	--prometheus-disable-route-logging=$(PROMETHEUS_DISABLE_ROUTE_LOGGING) \
+	--prometheus-disable-collect=$(PROMETHEUS_DISABLE_COLLECT) \
+	--webhook-allow-list="$(WEBHOOK_ALLOW_LIST)" \
+	--webhook-deny-list="$(WEBHOOK_DENY_LIST)" \
+	--webhook-error-allow-list=$(WEBHOOK_ERROR_ALLOW_LIST) \
+	--webhook-error-deny-list=$(WEBHOOK_ERROR_DENY_LIST) \
+	--webhook-max-retry=$(WEBHOOK_MAX_RETRY) \
+	--webhook-retry-min-wait=$(WEBHOOK_RETRY_MIN_WAIT) \
+	--webhook-retry-max-wait=$(WEBHOOK_RETRY_MAX_WAIT) \
+	--webhook-client-timeout=$(WEBHOOK_CLIENT_TIMEOUT) \
+	--webhook-disable=$(WEBHOOK_DISABLE)
+
+.PHONY: build-tests
+build-tests: ## Build the tests' Docker image
+	docker build \
+	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
+	--build-arg DOCKER_REGISTRY=$(DOCKER_REGISTRY) \
+	--build-arg DOCKER_REPOSITORY=$(DOCKER_REPOSITORY) \
+	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
+	--build-arg GOLANGCI_LINT_VERSION=$(GOLANGCI_LINT_VERSION) \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
+	-f test/Dockerfile .
+
+.PHONY: tests
+tests: ## Start the testing environment
+	docker run --rm -it \
+	-v $(PWD):/tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
+	bash
+
+.PHONY: tests-once
+tests-once: ## Run the tests once (prefer the "tests" command while developing)
+	docker run --rm  \
+	-v $(PWD):/tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
+	gotest
+
+# go install mvdan.cc/gofumpt@latest
+# go install github.com/daixiang0/gci@latest
+.PHONY: fmt
+fmt: ## Format the code and "optimize" the dependencies
+	gofumpt -l -w .
+	gci write -s standard -s default -s "prefix(github.com/gotenberg/gotenberg/v8)" --skip-generated --skip-vendor --custom-order .
+	go mod tidy
+
+# go install golang.org/x/tools/cmd/godoc@latest
+.PHONY: godoc
+godoc: ## Run a webserver with Gotenberg godoc
+	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v8)
+	godoc -http=:6060
+
+LINUX_AMD64_RELEASE=false
+
+.PHONY: release
+release: ## Build the Gotenberg's Docker image and push it to a Docker repository
+	./scripts/release.sh \
+ 	$(GOLANG_VERSION) \
+	$(GOTENBERG_VERSION) \
+	$(GOTENBERG_USER_GID) \
+	$(GOTENBERG_USER_UID) \
+	$(NOTO_COLOR_EMOJI_VERSION) \
+	$(PDFTK_VERSION) \
+	$(DOCKER_REGISTRY) \
+	$(DOCKER_REPOSITORY) \
+	$(LINUX_AMD64_RELEASE)
+

README.md

@@ -1,136 +1,50 @@
 <p align="center">
-    <img src="https://user-images.githubusercontent.com/8983173/38133342-11df3bd8-340f-11e8-9fe4-50baecdceeca.png" alt="Gotenberg's logo" width="250" height="250" />
-</p>
-<h3 align="center">Gotenberg</h3>
-<p align="center">A stateless API for converting Markdown files, HTML files and Office documents to PDF</p>
-<p align="center">
-    <a href="https://microbadger.com/images/thecodingmachine/gotenberg:1.0.0">
-        <img src="https://images.microbadger.com/badges/image/thecodingmachine/gotenberg:1.0.0.svg" alt="MicroBadger layers">
-    </a>
-    <a href="https://travis-ci.org/thecodingmachine/gotenberg">
-        <img src="https://travis-ci.org/thecodingmachine/gotenberg.svg?branch=1.0.0" alt="Travis CI">
-    </a>
-    <a href="https://godoc.org/github.com/thecodingmachine/gotenberg">
-        <img src="https://godoc.org/github.com/thecodingmachine/gotenberg?status.svg" alt="GoDoc">
-    </a>
-    <a href="https://goreportcard.com/report/thecodingmachine/gotenberg">
-        <img src="https://goreportcard.com/badge/github.com/thecodingmachine/gotenberg" alt="Go Report Card">
-    </a>
-    <a href="https://codecov.io/gh/thecodingmachine/gotenberg/branch/1.0.0">
-        <img src="https://codecov.io/gh/thecodingmachine/gotenberg/branch/1.0.0/graph/badge.svg" alt="Codecov">
-    </a>
+    <img src="https://user-images.githubusercontent.com/8983173/130322857-185831e2-f041-46eb-a17f-0a69d066c4e5.png" alt="Gotenberg Logo" width="150" height="150" />
+    <h3 align="center">Gotenberg</h3>
+    <p align="center">A Docker-powered stateless API for PDF files</p>
+    <p align="center">
+        <a href="https://hub.docker.com/r/gotenberg/gotenberg"><img alt="Total downloads (gotenberg/gotenberg)" src="https://img.shields.io/docker/pulls/gotenberg/gotenberg"></a>
+        <a href="https://hub.docker.com/r/thecodingmachine/gotenberg"><img alt="Total downloads (thecodingmachine/gotenberg)" src="https://img.shields.io/docker/pulls/thecodingmachine/gotenberg"></a>
+        <br>
+        <a href="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml"><img alt="Continuous Integration" src="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg"></a>
+        <a href="https://pkg.go.dev/github.com/gotenberg/gotenberg/v8"><img alt="Go Reference" src="https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg"></a>
+        <a href="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"><img alt="Code coverage" src="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"></a>
+    </p>
+    <p align="center"><a href="https://gotenberg.dev/docs/getting-started/introduction">Documentation</a> &#183; <a href="https://gotenberg.dev/docs/getting-started/installation#live-demo-">Live Demo</a> 🔥</p>
 </p>
 
 ---
 
-At TheCodingMachine, we build a lot of web applications (intranets, extranets and so on) which require to generate PDF from 
-various sources. Each time, we ended up using some well known libraries like **wkhtmltopdf** or **unoconv** and kind of lost time by
-reimplementing a solution from a project to another project. Meh.
+**Gotenberg** provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice for converting 
+numerous document formats (HTML, Markdown, Word, Excel, etc.) into PDF files, and more!
 
-# Menu
+## Quick Start
 
-* [Usage](#usage)
-* [Security](#security)
-* [Scalability](#scalability)
-* [Custom implementation](#custom-implementation)
-* [Clients](#clients)
+Open a terminal and run the following command:
 
-## Usage
-
-Let's say you're starting the API using this simple command:
-
-```sh
-$ docker run --rm -p 3000:3000 thecodingmachine/gotenberg:1.0.0
+```
+docker run --rm -p 3000:3000 gotenberg/gotenberg:8
 ```
 
-The API is now available on your host under `http://127.0.0.1:3000`.
+Alternatively, using the historic Docker repository from our sponsor [TheCodingMachine](https://www.thecodingmachine.com):
 
-It accepts `POST` requests with a `multipart/form-data` Content-Type. Your form data should provide one or more files to convert.
-It currently accepts the following:
-
-* Markdown files
-* HTML files
-* Office documents (.docx, .doc, .odt, .pptx, .ppt, .odp and so on)
-* PDF files (if more than one file to convert)
-
-**Heads up:** the API relies on the file extension to determine which library to use for conversion.
-
-There are two use cases:
-
-* If you send one file, it will convert it and return the resulting PDF
-* If many files, it will convert them to PDF, merge the resulting PDFs into a single PDF and return it
-
-### Examples:
-
-* One file
-
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.docx \
-    > result.pdf
+```
+docker run --rm -p 3000:3000 thecodingmachine/gotenberg:8
 ```
 
-* Many files
+The API is now available on your host at http://localhost:3000.
 
-```sh
-$ curl --request POST \
-    --url http://127.0.0.1:3000 \
-    --header 'Content-Type: multipart/form-data' \
-    --form files=@file.md \
-    --form files=@file.html \
-    --form files=@file.pdf \
-    --form files=@file.docx \
-    > result.pdf
-```
+Head to the [documentation](https://gotenberg.dev/docs/getting-started/introduction) to learn how to interact with it 🚀
 
-## Security
+## Sponsors
 
-The API does not provide any authentication mechanisms. Make sure to not put it on a public facing port and your client(s) should always 
-controls what is sent to the API.
+<p align="center">
+    <a href="https://thecodingmachine.com">
+        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="333" height="163" />
+    </a>
+    <a href="https://zolsec.com?utm_source=gotenberg_github&utm_medium=website" target="_blank">
+        <img src="https://github.com/gotenberg/gotenberg/assets/8983173/707ccc97-a79b-4dcb-8fc8-6827366e5be3" alt="Zolsec Logo" width="333" height="163" />
+    </a>
+</p>
 
-## Scalability
-
-Some libraries like **unoconv** cannot perform concurrent conversions. That's why the API does only one conversion at a time.
-If your API is under heavy load, a request will take time to be processed. 
-
-Fortunately, you may pass through this limitation by scaling the API.
-
-In the following example, I'll demonstrate how to do some vertical scaling (= on the same machine) with Docker Compose, but of course horizontal scaling works too!
-
-```yaml
-version: '3'
-
-services:
-
-  # your others services
-      
-  gotenberg:
-    image: gotenberg:1.0.0
-```
-
-You may now launch your services using:
-
-```bash
-docker-compose up --scale gotenberg=your_number_of_instances
-```
-
-When requesting the Gotenberg service with your client(s), Docker will automatically redirect a request to a Gotenberg container
-according to the round-robin strategy.
-
-## Custom implementation
-
-The API relies on a simple YAML configuration file called `gotenberg.yml`. It allows you to tweak some values and even provides you 
-a way to change the commands called for each kind of conversion. The configuration file should be located under `/gotenberg` in your container.
-
-The default configuration is located here: [.ci/gotenberg.yml](.ci/gotenberg.yml)
-
-## Clients
-
-* https://github.com/thecodingmachine/gotenberg-php-client (PHP client)
-* Add your own client by submitting a [pull request](../../pulls)!
-
----
-
-Would you like to update this documentation ? Feel free to open an [issue](../../issues).
+Sponsorships help maintaining and improving Gotenberg - [become a sponsor](https://github.com/sponsors/gulien) ❤️

SECURITY.md

@@ -0,0 +1,41 @@
+# Security Policy
+
+## Supported Versions
+
+Please ensure to keep your environment up-to-date and use only the latest version of Gotenberg. 
+Security updates and patches will be applied only to the most recent version.
+
+## Reporting a Vulnerability
+
+Your help in identifying vulnerabilities in our project is much appreciated. 
+We take all reports regarding security seriously.
+
+If you discover a security vulnerability, please refrain from publishing it publicly. 
+Instead, kindly send us the details via email to *neuhart [dot] julien [at] gmail [dot] com*.
+
+In the subject of your email, please indicate that it's a security vulnerability report for Gotenberg. 
+In your message, please include:
+
+* A detailed description of the vulnerability.
+* The steps to reproduce the issue.
+* Any potential impact of the vulnerability on the users or system.
+
+Please remember that this process is done in a *'best-effort'* manner. 
+This means we strive to respond and act as quickly as possible, but the speed may vary depending on the severity of
+the issue and our resources.
+
+Thank you in advance for helping to keep our project safe!
+
+## Disclosure Policy
+
+Once we have received your vulnerability report, we will work to validate and reproduce the issue. 
+If we can confirm the vulnerability, we will proceed to:
+
+* Work on a fix and a release timeline.
+* Notify you when the fix has been implemented and released.
+* Credit you for discovering the vulnerability (unless you request anonymity).
+* Please note that we will do our best to keep you informed about the progress towards resolving the issue.
+
+## Comments on this Policy
+
+If you have suggestions on how this process could be improved, please submit a pull request.

_tests/configurations/broken-gotenberg.yml

@@ -1,20 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: {
-      value: [
-      ...
-    }
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/merge-timeout-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 0
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/timeout-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 0
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 0
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 0
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 0
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-html-command-template-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-logging-format-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "DEBUG"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-logging-level-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "text"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-markdown-command-template-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-merge-command-template-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output {{ .ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} cat output {{ .ResultFilePath }}"

_tests/configurations/wrong-office-command-template-gotenberg.yml

@@ -1,17 +0,0 @@
-port: 3000
-logs:
-  level: "DEBUG"
-  format: "text"
-commands:
-  markdown:
-    timeout: 30
-    template: "markdown-pdf {{ .FilePath }} -o {{ .ResultFilePath }}"
-  html:
-    timeout: 30
-    template: "xvfb-run -e /dev/stdout wkhtmltopdf {{ .FilePath }} {{ .ResultFilePath }}"
-  office:
-    timeout: 30
-    template: "unoconv --format pdf --output \"{{ ResultFilePath }}\" \"{{ .FilePath }}\""
-  merge:
-    timeout: 30
-    template: "pdftk {{ range $filePath := .FilesPaths }} {{ $filePath }} {{ end }} cat output {{ .ResultFilePath }}"

_tests/file.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-  <meta charset="utf-8">
-  <title>Some title</title>
-  <meta name="author" content="Julien Neuhart">
-  <meta name="description" content="Simple HTML page">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-</head>
-
-<body>
-  <p>Hi! I have been converted from an HTML page!</p>
-</body>
-
-</html>

_tests/file.md

@@ -1 +0,0 @@
-# Hi, I've been converted from a markdown file!

app/config/config.go

@@ -1,254 +0,0 @@
-/*
-Package config contains all the logic allowing us to instantiate the application's configuration.
-
-The application's configuration is loaded from a YAML file named gotenberg.yml.
-It should be located where the user starts the application from the CLI.
-*/
-package config
-
-import (
-	"io/ioutil"
-	"text/template"
-
-	"github.com/sirupsen/logrus"
-	"gopkg.in/yaml.v2"
-)
-
-type (
-	// AppConfig gathers all data required to instantiate the application.
-	AppConfig struct {
-		// Port is the port which the application will listen to.
-		Port string
-		// Logs contains the logging configuration.
-		Logs struct {
-			// Level is the level of messages which will be logged.
-			Level logrus.Level
-			// Formatter defines the logging format when a TTY is not attached.
-			Formatter logrus.Formatter
-		}
-		// CommandsConfig is... an instance of CommandsConfig.
-		CommandsConfig *CommandsConfig
-	}
-
-	// CommandsConfig gathers all commands' configurations as defined
-	// by the user in the gotenberg.yml file.
-	CommandsConfig struct {
-		// Markdown is the command's configuration for converting
-		// an Markdown file to PDF.
-		Markdown *CommandConfig
-		// HTML is the command's configuration for converting
-		// an HTML file to PDF.
-		HTML *CommandConfig
-		// Office is the command's configuration for converting
-		// an Office document to PDF.
-		Office *CommandConfig
-		// Merge is the command's configuration for merging
-		// multiple PDF files into one PDF file.
-		Merge *CommandConfig
-	}
-
-	// CommandConfig is a command's configuration.
-	CommandConfig struct {
-		// Timeout is the duration in seconds after which the command's process will be killed
-		// if it does not finish before.
-		Timeout int
-		// Template is the data-driven template of the command.
-		Template *template.Template
-	}
-)
-
-// NewAppConfig instantiates the application's configuration.
-// If something bad happens here, the application should not start.
-func NewAppConfig(configurationFilePath string) (*AppConfig, error) {
-	fileConfig, err := loadFileConfig(configurationFilePath)
-	if err != nil {
-		return nil, err
-	}
-
-	c := &AppConfig{}
-	c.Port = fileConfig.Port
-
-	if err := makeLogs(c, fileConfig); err != nil {
-		return nil, err
-	}
-
-	if err := makeCommandsConfig(c, fileConfig); err != nil {
-		return nil, err
-	}
-
-	return c, nil
-}
-
-// fileConfig gathers all data coming from the configuration file gotenberg.yml.
-type fileConfig struct {
-	Port string `yaml:"port"`
-	Logs struct {
-		Level  string `yaml:"level"`
-		Format string `yaml:"format"`
-	} `yaml:"logs"`
-	Commands struct {
-		Markdown struct {
-			Timeout  int    `yaml:"timeout"`
-			Template string `yaml:"template"`
-		} `yaml:"markdown"`
-		HTML struct {
-			Timeout  int
-			Template string
-		} `yaml:"html"`
-		Office struct {
-			Timeout  int    `yaml:"timeout"`
-			Template string `yaml:"template"`
-		} `yaml:"office"`
-		Merge struct {
-			Timeout  int    `yaml:"timeout"`
-			Template string `yaml:"template"`
-		} `yaml:"merge"`
-	} `yaml:"commands"`
-}
-
-// loadFileConfig instantiates a fileConfig instance by loading
-// the configuration file gotenberg.yml.
-func loadFileConfig(configurationFilePath string) (*fileConfig, error) {
-	c := &fileConfig{}
-
-	data, err := ioutil.ReadFile(configurationFilePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := yaml.Unmarshal(data, &c); err != nil {
-		return nil, err
-	}
-
-	return c, nil
-}
-
-// makeLogs is a simple wrapper which populates all data related
-// to application's logging.
-func makeLogs(appConfig *AppConfig, fileConfig *fileConfig) error {
-	lvl, err := getLoggingLevelFromFileConfig(fileConfig)
-	if err != nil {
-		return err
-	}
-
-	formatter, err := getLoggingFormatterFromFileConfig(fileConfig)
-	if err != nil {
-		return err
-	}
-
-	appConfig.Logs.Level = lvl
-	appConfig.Logs.Formatter = formatter
-
-	return nil
-}
-
-// levels associates logging levels as defined in the configuration file gotenberg.yml
-// with its counterpart from the logrus library.
-var levels = map[string]logrus.Level{
-	"DEBUG": logrus.DebugLevel,
-	"INFO":  logrus.InfoLevel,
-	"WARN":  logrus.WarnLevel,
-	"ERROR": logrus.ErrorLevel,
-	"FATAL": logrus.FatalLevel,
-	"PANIC": logrus.PanicLevel,
-}
-
-type wrongLoggingLevelError struct{}
-
-const wrongLoggingLevelErrorMessage = "Accepted values for logging level: DEBUG, INFO, WARN, ERROR, FATAL, PANIC"
-
-func (e *wrongLoggingLevelError) Error() string {
-	return wrongLoggingLevelErrorMessage
-}
-
-// getLoggingLevelFromFileConfig returns a logrus level if a matching was found
-// with the one defined by the user.
-// If no match, throws an error.
-func getLoggingLevelFromFileConfig(c *fileConfig) (logrus.Level, error) {
-	l, ok := levels[c.Logs.Level]
-	if !ok {
-		return 999, &wrongLoggingLevelError{}
-	}
-
-	return l, nil
-}
-
-// levels associates logging formats as defined in the configuration file gotenberg.yml
-// with its counterpart from the logrus library.
-var formatters = map[string]logrus.Formatter{
-	"text": &logrus.TextFormatter{},
-	"json": &logrus.JSONFormatter{},
-}
-
-type wrongLoggingFormatError struct{}
-
-const wrongLoggingFormatErrorMessage = "Accepted value for logging format: text, json"
-
-func (e *wrongLoggingFormatError) Error() string {
-	return wrongLoggingFormatErrorMessage
-}
-
-// getLoggingLevelFromFileConfig returns a logrus Formatter if a matching was found
-// with the format defined by the user.
-// If no match, throws an error.
-func getLoggingFormatterFromFileConfig(c *fileConfig) (logrus.Formatter, error) {
-	f, ok := formatters[c.Logs.Format]
-	if !ok {
-		return nil, &wrongLoggingFormatError{}
-	}
-
-	return f, nil
-}
-
-// makeCommandsConfigs is a simple wrapper which populates all data related
-// to commands' configurations.
-func makeCommandsConfig(appConfig *AppConfig, fileConfig *fileConfig) error {
-	appConfig.CommandsConfig = &CommandsConfig{}
-	appConfig.CommandsConfig.Markdown = &CommandConfig{}
-	appConfig.CommandsConfig.HTML = &CommandConfig{}
-	appConfig.CommandsConfig.Office = &CommandConfig{}
-	appConfig.CommandsConfig.Merge = &CommandConfig{}
-
-	appConfig.CommandsConfig.Markdown.Timeout = fileConfig.Commands.Markdown.Timeout
-	appConfig.CommandsConfig.HTML.Timeout = fileConfig.Commands.HTML.Timeout
-	appConfig.CommandsConfig.Office.Timeout = fileConfig.Commands.Office.Timeout
-	appConfig.CommandsConfig.Merge.Timeout = fileConfig.Commands.Merge.Timeout
-
-	tmplMarkdown, err := getCommandTemplate(fileConfig.Commands.Markdown.Template, "Markdown")
-	if err != nil {
-		return err
-	}
-
-	tmplHTML, err := getCommandTemplate(fileConfig.Commands.HTML.Template, "HTML")
-	if err != nil {
-		return err
-	}
-
-	tmplOffice, err := getCommandTemplate(fileConfig.Commands.Office.Template, "Office")
-	if err != nil {
-		return err
-	}
-
-	tmplMerge, err := getCommandTemplate(fileConfig.Commands.Merge.Template, "Merge")
-	if err != nil {
-		return err
-	}
-
-	appConfig.CommandsConfig.Markdown.Template = tmplMarkdown
-	appConfig.CommandsConfig.HTML.Template = tmplHTML
-	appConfig.CommandsConfig.Office.Template = tmplOffice
-	appConfig.CommandsConfig.Merge.Template = tmplMerge
-
-	return nil
-}
-
-// getCommandTemplate is a simple helper for parsing a command template as defined by the user.
-// If the user gives us a wrong template, throws an error.
-func getCommandTemplate(command string, commandName string) (*template.Template, error) {
-	t, err := template.New(commandName).Parse(command)
-	if err != nil {
-		return nil, err
-	}
-
-	return t, nil
-}

app/config/config_test.go

@@ -1,77 +0,0 @@
-package config
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestNewAppConfig(t *testing.T) {
-	var path string
-
-	// case 1: uses an empty configuration file path.
-	if _, err := NewAppConfig(""); err == nil {
-		t.Error("AppConfig should not have been instantiated by using an empty configuration file path")
-	}
-
-	// case 2: uses a broken configuration file.
-	path, _ = filepath.Abs("../../_tests/configurations/broken-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 3: uses a configuration file with a wrong logging level.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-logging-level-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 4: uses a configuration file with a wrong logging format.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-logging-format-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 5: uses a configuration file with a wrong markdown command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-markdown-command-template-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 6: uses a configuration file with a wrong HTML command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-html-command-template-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 7: uses a configuration file with a wrong Office command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-office-command-template-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 8: uses a configuration file with a wrong merge command template.
-	path, _ = filepath.Abs("../../_tests/configurations/wrong-merge-command-template-gotenberg.yml")
-	if _, err := NewAppConfig(path); err == nil {
-		t.Errorf("AppConfig should not have been instantiated with '%s'", path)
-	}
-
-	// case 9: uses a correct configuration file.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	if _, err := NewAppConfig(path); err != nil {
-		t.Errorf("AppConfig should have been instantiated with '%s'", path)
-	}
-}
-
-func TestWrongLoggingLevelError(t *testing.T) {
-	err := &wrongLoggingLevelError{}
-	if err.Error() != wrongLoggingLevelErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), wrongLoggingLevelErrorMessage)
-	}
-}
-
-func TestWrongLoggingFormatError(t *testing.T) {
-	err := &wrongLoggingFormatError{}
-	if err.Error() != wrongLoggingFormatErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), wrongLoggingFormatErrorMessage)
-	}
-}

app/context/context.go

@@ -1,75 +0,0 @@
-// Package context provides functions for setting and getting values from
-// a request's context.
-package context
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/thecodingmachine/gotenberg/app/converter"
-)
-
-type key uint32
-
-const (
-	converterKey key = iota
-	resultFilePathKey
-)
-
-// WithConverter populates a request's context with the given converter
-// and returns the updated request.
-func WithConverter(r *http.Request, converter *converter.Converter) *http.Request {
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, converterKey, converter)
-	r = r.WithContext(ctx)
-
-	return r
-}
-
-type converterNotFoundError struct{}
-
-const converterNotFoundErrorMessage = "The converter was not found in request context"
-
-func (e *converterNotFoundError) Error() string {
-	return converterNotFoundErrorMessage
-}
-
-// GetConverter returns the converter if found in
-// the request's context. Otherwise throws an error.
-func GetConverter(r *http.Request) (*converter.Converter, error) {
-	c, ok := r.Context().Value(converterKey).(*converter.Converter)
-	if !ok {
-		return nil, &converterNotFoundError{}
-	}
-
-	return c, nil
-}
-
-// WithResultFilePath populates a request's context with the given result file path
-// and returns the updated request.
-func WithResultFilePath(r *http.Request, resultFilePath string) *http.Request {
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, resultFilePathKey, resultFilePath)
-	r = r.WithContext(ctx)
-
-	return r
-}
-
-type resultFilePathNotFoundError struct{}
-
-const resultFilePathNotFoundErrorMessage = "The result file path was not found in request context"
-
-func (e *resultFilePathNotFoundError) Error() string {
-	return resultFilePathNotFoundErrorMessage
-}
-
-// GetResultFilePath returns the result file path if found in
-// the request's context. Otherwise throws an error.
-func GetResultFilePath(r *http.Request) (string, error) {
-	path, ok := r.Context().Value(resultFilePathKey).(string)
-	if !ok {
-		return "", &resultFilePathNotFoundError{}
-	}
-
-	return path, nil
-}

app/context/context_test.go

@@ -1,68 +0,0 @@
-package context
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/converter"
-)
-
-func TestWithConverter(t *testing.T) {
-	req := WithConverter(httptest.NewRequest(http.MethodPost, "/", nil), &converter.Converter{})
-	if c, _ := req.Context().Value(converterKey).(*converter.Converter); c == nil {
-		t.Errorf("Context returned a wrong converter: got '%v' want not nil", c)
-	}
-}
-
-func TestGetConverter(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a converter entry in its context.
-	if _, err := GetConverter(req); err == nil {
-		t.Error("Context should not have a converter entry")
-	}
-
-	// case 2: uses a request with a converter entry in its context.
-	req = WithConverter(req, &converter.Converter{})
-	if _, err := GetConverter(req); err != nil {
-		t.Error("Context should have a converter entry")
-	}
-}
-
-func TestWithResultFilePath(t *testing.T) {
-	filePath := "file.pdf"
-	req := WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), filePath)
-	if path, _ := req.Context().Value(resultFilePathKey).(string); path != filePath {
-		t.Errorf("Context returned a wrong result file path: got '%s' want '%s'", path, filePath)
-	}
-}
-
-func TestGetResultFilePath(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a result file path entry in its context.
-	if _, err := GetResultFilePath(req); err == nil {
-		t.Error("Context should not have a result file path entry")
-	}
-
-	// case 2: uses a request with a result file path entry in its context.
-	req = WithResultFilePath(req, "file.pdf")
-	if _, err := GetResultFilePath(req); err != nil {
-		t.Error("Context should have a result file path entry")
-	}
-}
-
-func TestConverterNotFoundError(t *testing.T) {
-	err := &converterNotFoundError{}
-	if err.Error() != converterNotFoundErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), converterNotFoundErrorMessage)
-	}
-}
-
-func TestResultFilePathNotFoundError(t *testing.T) {
-	err := &resultFilePathNotFoundError{}
-	if err.Error() != resultFilePathNotFoundErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), resultFilePathNotFoundErrorMessage)
-	}
-}

app/converter/converter.go

@@ -1,105 +0,0 @@
-// Package converter implements a solution for converting one or more files to PDF.
-package converter
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-	"github.com/thecodingmachine/gotenberg/app/converter/process"
-
-	"github.com/satori/go.uuid"
-)
-
-// Converter handles conversion into PDF of files coming from a request.
-type Converter struct {
-	files      []*gfile.File
-	workingDir string
-}
-
-// NoFileToConvertError is raided when a request has not file attached to it.
-type NoFileToConvertError struct{}
-
-const noFileToConvertErrorMessage = "No file to convert"
-
-func (e *NoFileToConvertError) Error() string {
-	return noFileToConvertErrorMessage
-}
-
-// NewConverter instantiates a converter by parsing a request.
-func NewConverter(r *http.Request) (*Converter, error) {
-	c := &Converter{
-		workingDir: fmt.Sprintf("./%s/", uuid.NewV4().String()),
-	}
-
-	if err := os.Mkdir(c.workingDir, 0666); err != nil {
-		return nil, err
-	}
-
-	reader, err := r.MultipartReader()
-	if err != nil {
-		return c, err
-	}
-
-	for {
-		part, err := reader.NextPart()
-		if err == io.EOF {
-			break
-		}
-
-		fileName := part.FileName()
-		if fileName == "" {
-			continue
-		}
-
-		f, err := gfile.NewFile(c.workingDir, part, fileName)
-		if err != nil {
-			return c, err
-		}
-
-		c.files = append(c.files, f)
-	}
-
-	if len(c.files) == 0 {
-		return c, &NoFileToConvertError{}
-	}
-
-	return c, nil
-}
-
-// Convert converts its associated files to PDF. If more than one file,
-// it will merge all of them into one unique PDF file.
-// Returns the new file path or an error if something bad happened.
-func (c *Converter) Convert() (string, error) {
-	var filesPaths []string
-	for _, f := range c.files {
-		if f.Type != gfile.PDFType {
-			path, err := process.Unconv(c.workingDir, f)
-			if err != nil {
-				return "", err
-			}
-
-			filesPaths = append(filesPaths, path)
-		} else {
-			filesPaths = append(filesPaths, f.Path)
-		}
-	}
-
-	if len(filesPaths) == 1 {
-		return filesPaths[0], nil
-	}
-
-	path, err := process.Merge(c.workingDir, filesPaths)
-	if err != nil {
-		return "", err
-	}
-
-	return path, nil
-}
-
-// Clear removes all file inside its working directory.
-func (c *Converter) Clear() error {
-	return os.RemoveAll(c.workingDir)
-}

app/converter/converter_test.go

@@ -1,147 +0,0 @@
-package converter
-
-import (
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/converter/process"
-)
-
-func makeRequest(filesPaths ...string) *http.Request {
-	r, w := io.Pipe()
-	mpw := multipart.NewWriter(w)
-
-	go func() {
-		var part io.Writer
-		defer w.Close()
-
-		if len(filesPaths) == 0 {
-			part, _ = mpw.CreateFormField("foo")
-			part.Write([]byte("bar"))
-		} else {
-			for _, filePath := range filesPaths {
-				file, _ := os.Open(filePath)
-				defer file.Close()
-
-				fileInfo, _ := file.Stat()
-				part, _ = mpw.CreateFormFile("files", fileInfo.Name())
-				io.Copy(part, file)
-			}
-		}
-
-		mpw.Close()
-	}()
-
-	req := httptest.NewRequest(http.MethodPost, "/", r)
-	req.Header.Set("Content-Type", mpw.FormDataContentType())
-	return req
-}
-
-func loadCommandConfigs(configurationFilePath string) {
-	path, _ := filepath.Abs(configurationFilePath)
-	c, _ := config.NewAppConfig(path)
-	process.Load(c.CommandsConfig)
-}
-
-func TestNewConverter(t *testing.T) {
-	var (
-		path  string
-		oPath string
-	)
-
-	// case 1: uses a request with a single file.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path)); err != nil {
-		t.Errorf("Converter should have been instantiated with '%s'", path)
-	}
-
-	// case 2: uses a request with wrong file type.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	if _, err := NewConverter(makeRequest(path)); err == nil {
-		t.Errorf("Converter should not have been instantiated with '%s'", path)
-	}
-
-	// case 3: uses a request with two files.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path, oPath)); err != nil {
-		t.Errorf("Converter should have been instantiated with '%s' and '%s'", path, oPath)
-	}
-
-	// case 4: uses a request with one Office file type and one wrong file type.
-	path, _ = filepath.Abs("../../_tests/configurations/gotenberg.yml")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	if _, err := NewConverter(makeRequest(path, oPath)); err == nil {
-		t.Errorf("Converter should not have been instantiated with '%s' and '%s'", path, oPath)
-	}
-
-	// case 5: uses a request with no file.
-	if _, err := NewConverter(makeRequest()); err == nil {
-		t.Error("Converter should not have been instantiated with no file")
-	}
-}
-
-func TestConvert(t *testing.T) {
-	var (
-		path  string
-		oPath string
-		c     *Converter
-	)
-
-	loadCommandConfigs("../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses a request with a single file.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path))
-	if _, err := c.Convert(); err != nil {
-		t.Errorf("Converter should have been able to convert '%s' to PDF", path)
-	}
-
-	// case 2: uses a request with two files.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path, oPath))
-	if _, err := c.Convert(); err != nil {
-		t.Errorf("Converter should have been able to convert '%s' and '%s' to PDF", path, oPath)
-	}
-
-	loadCommandConfigs("../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 3: uses a request with a single file and a configuration with an unsuitable timeout for the conversion commands.
-	path, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path))
-	if _, err := c.Convert(); err == nil {
-		t.Errorf("Converter should not have been able to convert '%s' to PDF", path)
-	}
-
-	loadCommandConfigs("../../_tests/configurations/merge-timeout-gotenberg.yml")
-
-	// case 4: uses a request with two files and a configuration with an unsuitable timeout for the merge command.
-	path, _ = filepath.Abs("../../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../../_tests/file.docx")
-	c, _ = NewConverter(makeRequest(path, oPath))
-	if _, err := c.Convert(); err == nil {
-		t.Errorf("Converter should not have been able to merge '%s' and '%s' into PDF", path, oPath)
-	}
-}
-
-func TestClear(t *testing.T) {
-	path, _ := filepath.Abs("../../_tests/file.docx")
-	c, _ := NewConverter(makeRequest(path))
-	if err := c.Clear(); err != nil {
-		t.Error("Converter should have been able to clear itself")
-	}
-}
-
-func TestNoFileToConvertError(t *testing.T) {
-	err := &NoFileToConvertError{}
-	if err.Error() != noFileToConvertErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), noFileToConvertErrorMessage)
-	}
-}

app/converter/file/file.go

@@ -1,98 +0,0 @@
-// Package file implements a solution for handling files coming from a request.
-package file
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/satori/go.uuid"
-)
-
-// File represents a file which has been created
-// from a request.
-type File struct {
-	// Type is the kind of file.
-	Type Type
-	// Path is the file path.
-	Path string
-}
-
-// Type represents what kind of file we're dealing with.
-type Type uint32
-
-const (
-	// PDFType represents a... PDF file.
-	PDFType Type = iota
-	// MarkdownType represents a... Markdown file.
-	MarkdownType
-	// HTMLType represents an... HTML file.
-	HTMLType
-	// OfficeType represents an... Office document.
-	OfficeType
-)
-
-// filesTypes associates a file extension with its file kind counterpart.
-var filesTypes = map[string]Type{
-	".pdf":  PDFType,
-	".md":   MarkdownType,
-	".htm":  HTMLType,
-	".html": HTMLType,
-	".doc":  OfficeType,
-	".docx": OfficeType,
-	".odt":  OfficeType,
-	".xls":  OfficeType,
-	".xlsx": OfficeType,
-	".ods":  OfficeType,
-	".ppt":  OfficeType,
-	".pptx": OfficeType,
-	".odp":  OfficeType,
-}
-
-type fileTypeNotFoundError struct {
-	fileName string
-}
-
-func (e *fileTypeNotFoundError) Error() string {
-	return fmt.Sprintf("File type was not found for '%s'", e.fileName)
-}
-
-// NewFile creates a file in the considered directory.
-// Returns a *File instance or an error if something bad happened.
-func NewFile(workingDir string, r io.Reader, fileName string) (*File, error) {
-	ext := filepath.Ext(fileName)
-
-	t, ok := filesTypes[ext]
-	if !ok {
-		return nil, &fileTypeNotFoundError{fileName: fileName}
-	}
-
-	f := &File{
-		Path: MakeFilePath(workingDir, ext),
-		Type: t,
-	}
-
-	file, err := os.Create(f.Path)
-	if err != nil {
-		return nil, err
-	}
-
-	defer file.Close()
-
-	_, err = io.Copy(file, r)
-	if err != nil {
-		return nil, err
-	}
-
-	// resets the read pointer.
-	file.Seek(0, 0)
-
-	return f, nil
-}
-
-// MakeFilePath is a simple helper which generates a random file name
-// and associates it with the considered directory to make a path.
-func MakeFilePath(workingDir string, ext string) string {
-	return fmt.Sprintf("%s%s%s", workingDir, uuid.NewV4().String(), ext)
-}

app/converter/file/file_test.go

@@ -1,37 +0,0 @@
-package file
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestNewFile(t *testing.T) {
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	// case 1: uses a wrong file name.
-	if _, err := NewFile(workingDir, new(bytes.Buffer), "file.yml"); err == nil {
-		t.Error("File should not have been instantiated with an empty buffer")
-	}
-
-	// case 2: uses a reader from a correct file type.
-	filePath, _ := filepath.Abs("../../../_tests/file.pdf")
-	r, _ := os.Open(filePath)
-	defer r.Close()
-	if _, err := NewFile(workingDir, r, "file.pdf"); err != nil {
-		t.Errorf("File should have been instantiated using a reader from '%s'", filePath)
-	}
-
-	os.RemoveAll(workingDir)
-}
-func TestFileTypeNotFoundError(t *testing.T) {
-	fileName := "file.wp"
-	err := &fileTypeNotFoundError{fileName: fileName}
-	expected := fmt.Sprintf("File type was not found for '%s'", fileName)
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}

app/converter/process/process.go

@@ -1,155 +0,0 @@
-// Package process handles all commands executions.
-package process
-
-import (
-	"bytes"
-	"fmt"
-	"os/exec"
-	"sync"
-	"text/template"
-	"time"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-)
-
-type runner struct {
-	mu             sync.Mutex
-	commandsConfig *config.CommandsConfig
-}
-
-var forest = &runner{}
-
-type commandTimeoutError struct {
-	command string
-	timeout int
-}
-
-func (e *commandTimeoutError) Error() string {
-	return fmt.Sprintf("The command '%s' has reached the %d second(s) timeout", e.command, e.timeout)
-}
-
-// run runs the given command. If timeout is reached or
-// something bad happened, returns an error.
-func (r *runner) run(command string, timeout int) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	cmd := exec.Command("/bin/sh", "-c", command)
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	done := make(chan error, 1)
-	go func() {
-		done <- cmd.Wait()
-	}()
-
-	// wait for the process to finish or kill it after a timeout.
-	select {
-	case <-time.After(time.Duration(timeout) * time.Second):
-		if err := cmd.Process.Kill(); err != nil {
-			return err
-		}
-		return &commandTimeoutError{
-			command: command,
-			timeout: timeout,
-		}
-	case err := <-done:
-		if err != nil {
-			return err
-		}
-
-		return nil
-	}
-}
-
-// Load loads the commands configuration coming from the application configuration.
-func Load(config *config.CommandsConfig) {
-	forest.commandsConfig = config
-}
-
-// conversionData will be applied to the data-driven templates of conversions commands.
-type conversionData struct {
-	FilePath       string
-	ResultFilePath string
-}
-
-type impossibleConversionError struct{}
-
-const impossibleConversionErrorMessage = "Impossible conversion"
-
-func (e *impossibleConversionError) Error() string {
-	return impossibleConversionErrorMessage
-}
-
-// Unconv converts a file to PDF and returns the new file path.
-func Unconv(workingDir string, file *gfile.File) (string, error) {
-	cmdData := &conversionData{
-		FilePath:       file.Path,
-		ResultFilePath: gfile.MakeFilePath(workingDir, ".pdf"),
-	}
-
-	var (
-		cmdTimeout  int
-		cmdTemplate *template.Template
-	)
-
-	switch file.Type {
-	case gfile.MarkdownType:
-		cmdTimeout = forest.commandsConfig.Markdown.Timeout
-		cmdTemplate = forest.commandsConfig.Markdown.Template
-		break
-	case gfile.HTMLType:
-		cmdTimeout = forest.commandsConfig.HTML.Timeout
-		cmdTemplate = forest.commandsConfig.HTML.Template
-		break
-	case gfile.OfficeType:
-		cmdTimeout = forest.commandsConfig.Office.Timeout
-		cmdTemplate = forest.commandsConfig.Office.Template
-		break
-	default:
-		return "", &impossibleConversionError{}
-	}
-
-	var data bytes.Buffer
-	if err := cmdTemplate.Execute(&data, cmdData); err != nil {
-		return "", err
-	}
-
-	err := forest.run(data.String(), cmdTimeout)
-	if err != nil {
-		return "", err
-	}
-
-	return cmdData.ResultFilePath, nil
-}
-
-// mergeData will be applied to the data-driven template of the merge command.
-type mergeData struct {
-	FilesPaths     []string
-	ResultFilePath string
-}
-
-// Merge merges many PDF files to one unique PDF file and returns the new file path.
-func Merge(workingDir string, filesPaths []string) (string, error) {
-	cmdData := &mergeData{
-		FilesPaths:     filesPaths,
-		ResultFilePath: gfile.MakeFilePath(workingDir, ".pdf"),
-	}
-
-	cmdTimeout := forest.commandsConfig.Merge.Timeout
-	cmdTemplate := forest.commandsConfig.Merge.Template
-
-	var data bytes.Buffer
-	if err := cmdTemplate.Execute(&data, cmdData); err != nil {
-		return "", err
-	}
-
-	err := forest.run(data.String(), cmdTimeout)
-	if err != nil {
-		return "", err
-	}
-
-	return cmdData.ResultFilePath, nil
-}

app/converter/process/process_test.go

@@ -1,148 +0,0 @@
-package process
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	gfile "github.com/thecodingmachine/gotenberg/app/converter/file"
-)
-
-func makeFile(workingDir string, fileName string) *gfile.File {
-	filePath := fmt.Sprintf("%s%s", "../../../_tests/", fileName)
-	absPath, _ := filepath.Abs(filePath)
-
-	r, _ := os.Open(absPath)
-	defer r.Close()
-
-	f, _ := gfile.NewFile(workingDir, r, fileName)
-
-	return f
-}
-
-func loadCommandConfigs(configurationFilePath string) {
-	path, _ := filepath.Abs(configurationFilePath)
-	c, _ := config.NewAppConfig(path)
-	Load(c.CommandsConfig)
-}
-
-func TestLoad(t *testing.T) {
-	path, _ := filepath.Abs("../../../_tests/configurations/gotenberg.yml")
-	c, _ := config.NewAppConfig(path)
-	Load(c.CommandsConfig)
-
-	if c.CommandsConfig != forest.commandsConfig {
-		t.Error("Commands configuration should have been loaded correctly")
-	}
-}
-
-func TestRun(t *testing.T) {
-	var cmd string
-
-	// case 1: uses a simple command.
-	cmd = "echo Hello world"
-	if err := forest.run(cmd, 30); err != nil {
-		t.Errorf("Command '%s' should have worked", cmd)
-	}
-
-	// case 2: uses a simple command but with an unsuitable timeout.
-	cmd = "sleep 5"
-	if err := forest.run(cmd, 0); err == nil {
-		t.Errorf("Command '%s' should not have worked", cmd)
-	}
-
-	// case 3: uses a broken command.
-	cmd = "helloworld"
-	if err := forest.run(cmd, 30); err == nil {
-		t.Errorf("Command '%s' should not have worked", cmd)
-	}
-}
-
-func TestUnconv(t *testing.T) {
-	var file *gfile.File
-
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	loadCommandConfigs("../../../_tests/configurations/gotenberg.yml")
-
-	// case 1: uses an Markdown file type.
-	file = makeFile(workingDir, "file.md")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 2: uses an HTML file type.
-	file = makeFile(workingDir, "file.html")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 3: uses an Office file type.
-	file = makeFile(workingDir, "file.docx")
-	if _, err := Unconv(workingDir, file); err != nil {
-		t.Errorf("Converting '%s' to PDF should have worked", file.Path)
-	}
-
-	// case 4: uses a PDF file type.
-	file = makeFile(workingDir, "file.pdf")
-	if _, err := Unconv(workingDir, file); err == nil {
-		t.Errorf("Converting '%s' to PDF should not have worked", file.Path)
-	}
-
-	loadCommandConfigs("../../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 5: uses a command with an unsuitable timeout.
-	file = makeFile(workingDir, "file.docx")
-	if _, err := Unconv(workingDir, makeFile(workingDir, "file.docx")); err == nil {
-		t.Errorf("Converting '%s' to PDF should have reached timeout", file.Path)
-	}
-
-	os.RemoveAll(workingDir)
-}
-
-func TestMerge(t *testing.T) {
-	workingDir := "test"
-	os.Mkdir(workingDir, 0666)
-
-	loadCommandConfigs("../../../_tests/configurations/gotenberg.yml")
-
-	var filesPaths []string
-	path, _ := filepath.Abs("../../../_tests/file.pdf")
-	filesPaths = append(filesPaths, path)
-	filesPaths = append(filesPaths, path)
-
-	// case 1: simple merge.
-	if _, err := Merge(workingDir, filesPaths); err != nil {
-		t.Error("Merge should have worked")
-	}
-
-	loadCommandConfigs("../../../_tests/configurations/timeout-gotenberg.yml")
-
-	// case 2: uses a command with an unsuitable timeout.
-	if _, err := Merge(workingDir, filesPaths); err == nil {
-		t.Error("Merge should have reached timeout")
-	}
-
-	os.RemoveAll(workingDir)
-}
-
-func TestImpossibleConversionError(t *testing.T) {
-	err := &impossibleConversionError{}
-	if err.Error() != impossibleConversionErrorMessage {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), impossibleConversionErrorMessage)
-	}
-}
-
-func TestCommandTimeoutError(t *testing.T) {
-	err := &commandTimeoutError{
-		command: "echo hello",
-		timeout: 30,
-	}
-	expected := fmt.Sprintf("The command '%s' has reached the %d second(s) timeout", err.command, err.timeout)
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}

app/handlers.go

@@ -1,153 +0,0 @@
-// Package app implements all functions on which a request will pass through.
-package app
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	"github.com/thecodingmachine/gotenberg/app/context"
-	"github.com/thecodingmachine/gotenberg/app/converter"
-	ghttp "github.com/thecodingmachine/gotenberg/app/http"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/justinas/alice"
-)
-
-// GetHandlersChain returns the handlers chaining
-// thanks to the alice library.
-func GetHandlersChain() http.Handler {
-	return alice.New(enforceContentLengthHandler, enforceContentTypeHandler, convertHandler).ThenFunc(serveHandler)
-}
-
-type requestHasNoContentError struct{}
-
-func (e *requestHasNoContentError) Error() string {
-	return "Request has not content"
-}
-
-// enforeContentLengthHandler checks if the request has content.
-func enforceContentLengthHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.ContentLength == 0 {
-			e := &requestHasNoContentError{}
-			http.Error(w, e.Error(), http.StatusBadRequest)
-			logger.Error(e)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// enforceContentTypeHandler checks if the "Content-Type" entry
-// from the request's header matches the allowed content type.
-func enforceContentTypeHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := ghttp.CheckAuthorizedContentType(r.Header); err != nil {
-			http.Error(w, err.Error(), http.StatusUnsupportedMediaType)
-			logger.Error(err)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// convertHandler is in charge of converting the file(s) from the request to PDF.
-func convertHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		c, err := converter.NewConverter(r)
-		if err != nil {
-			if _, ok := err.(*converter.NoFileToConvertError); ok {
-				http.Error(w, err.Error(), http.StatusBadRequest)
-			} else {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-
-			logger.Error(err)
-
-			if c != nil {
-				r = context.WithConverter(r, c)
-				cleanup(r)
-			}
-
-			return
-		}
-
-		r = context.WithConverter(r, c)
-
-		path, err := c.Convert()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			logger.Error(err)
-			cleanup(r)
-			return
-		}
-
-		r = context.WithResultFilePath(r, path)
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// serveHandler simply serves the created PDF.
-func serveHandler(w http.ResponseWriter, r *http.Request) {
-	path, err := context.GetResultFilePath(r)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	reader, err := os.Open(path)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	defer reader.Close()
-
-	resultFileInfo, err := reader.Stat()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-		cleanup(r)
-		return
-	}
-
-	done := make(chan error, 1)
-	go func() {
-		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", resultFileInfo.Name()))
-		w.Header().Set("Content-Type", "application/pdf")
-		w.Header().Set("Content-Length", fmt.Sprintf("%d", resultFileInfo.Size()))
-		_, err := io.Copy(w, reader)
-
-		done <- err
-	}()
-
-	err = <-done
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		logger.Error(err)
-	}
-
-	cleanup(r)
-}
-
-// cleanup removes all files created during the conversion.
-func cleanup(r *http.Request) {
-	c, err := context.GetConverter(r)
-	if err != nil {
-		logger.Warn(err.Error())
-		return
-	}
-
-	if err := c.Clear(); err != nil {
-		logger.Warn(err.Error())
-	}
-}

app/handlers_test.go

@@ -1,221 +0,0 @@
-package app
-
-import (
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/context"
-	"github.com/thecodingmachine/gotenberg/app/converter/process"
-
-	"github.com/justinas/alice"
-)
-
-func makeRequest(filesPaths ...string) *http.Request {
-	r, w := io.Pipe()
-	mpw := multipart.NewWriter(w)
-
-	go func() {
-		var part io.Writer
-		defer w.Close()
-
-		if len(filesPaths) == 0 {
-			part, _ = mpw.CreateFormField("foo")
-			part.Write([]byte("bar"))
-		} else {
-			for _, filePath := range filesPaths {
-				file, _ := os.Open(filePath)
-				defer file.Close()
-
-				fileInfo, _ := file.Stat()
-				part, _ = mpw.CreateFormFile("files", fileInfo.Name())
-				io.Copy(part, file)
-			}
-		}
-
-		mpw.Close()
-	}()
-
-	req := httptest.NewRequest(http.MethodPost, "/", r)
-	req.Header.Set("Content-Type", mpw.FormDataContentType())
-	return req
-}
-
-func loadCommandConfigs(configurationFilePath string) {
-	path, _ := filepath.Abs(configurationFilePath)
-	c, _ := config.NewAppConfig(path)
-	process.Load(c.CommandsConfig)
-}
-
-func fakeSuccessHandler(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(http.StatusOK)
-}
-
-func TestGetHandlersChain(t *testing.T) {
-	// dumb test to improve code coverage...
-	if GetHandlersChain() == nil {
-		t.Errorf("Handler chains should not be nil")
-	}
-}
-
-func TestEnforceContentLengthHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New(enforceContentLengthHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends an empty request.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusBadRequest {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusBadRequest)
-	}
-
-	// case 2: sends a real body.
-	path, _ := filepath.Abs("../_tests/file.docx")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, makeRequest(path))
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}
-
-func TestEnforceContentTypeHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New(enforceContentTypeHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends a wrong content type.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	req.Header.Set("Content-Type", "application/pdf")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusUnsupportedMediaType {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusUnsupportedMediaType)
-	}
-
-	// case 2: sends a good content type.
-	path, _ := filepath.Abs("../_tests/file.docx")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, makeRequest(path))
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned wrong a status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}
-
-func TestConvertHandler(t *testing.T) {
-	var (
-		req   *http.Request
-		rr    *httptest.ResponseRecorder
-		path  string
-		oPath string
-	)
-
-	h := alice.New(convertHandler).ThenFunc(fakeSuccessHandler)
-
-	// case 1: sends a request without body.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 2: sends a request with no file.
-	req = makeRequest()
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusBadRequest {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusBadRequest)
-	}
-
-	loadCommandConfigs("../_tests/configurations/merge-timeout-gotenberg.yml")
-
-	// case 3: sends a request with two files and using an unsuitable timeout for merge commande.
-	path, _ = filepath.Abs("../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../_tests/file.docx")
-	req = makeRequest(path, oPath)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	loadCommandConfigs("../_tests/configurations/gotenberg.yml")
-
-	// case 4: sends a request with two files.
-	path, _ = filepath.Abs("../_tests/file.pdf")
-	oPath, _ = filepath.Abs("../_tests/file.docx")
-	req = makeRequest(path, oPath)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-
-	// case 5: sends five requests (almost) simultany.
-	path, _ = filepath.Abs("../_tests/file.docx")
-	filesPaths := []string{
-		path,
-		path,
-		path,
-		path,
-		path,
-	}
-
-	for i := 0; i < len(filesPaths); i++ {
-		go func(i int) {
-			req := makeRequest(filesPaths[i])
-			rr := httptest.NewRecorder()
-			h.ServeHTTP(rr, req)
-			if status := rr.Code; status != http.StatusOK {
-				t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-			}
-		}(i)
-	}
-}
-
-func TestServeHandler(t *testing.T) {
-	var (
-		req *http.Request
-		rr  *httptest.ResponseRecorder
-	)
-
-	h := alice.New().ThenFunc(serveHandler)
-
-	// case 1: sends a request without a result file path entry in its context.
-	req = httptest.NewRequest(http.MethodPost, "/", nil)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 2: sends a request with a wrong result file path entry in its context.
-	req = context.WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), "file")
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusInternalServerError {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusInternalServerError)
-	}
-
-	// case 3: sends a request with a correct result file path entry in its context.
-	path, _ := filepath.Abs("../_tests/file.pdf")
-	req = context.WithResultFilePath(httptest.NewRequest(http.MethodPost, "/", nil), path)
-	rr = httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-	if status := rr.Code; status != http.StatusOK {
-		t.Errorf("Handler returned a wrong status code: got '%v' want '%v'", status, http.StatusOK)
-	}
-}

app/http/http.go

@@ -1,47 +0,0 @@
-// Package http provides functions for detecting a request or a file content type.
-package http
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-)
-
-// ContentType is a string which represents a content type.
-type ContentType string
-
-// MultipartFormDataContentType represents... the multipart form data content type.
-const MultipartFormDataContentType ContentType = "multipart/form-data"
-
-type notAuthorizedContentTypeError struct{}
-
-func (e *notAuthorizedContentTypeError) Error() string {
-	return fmt.Sprintf("Accepted value for 'Content-Type': %s", MultipartFormDataContentType)
-}
-
-// CheckAuthorizedContentType checks if the request header header has an authorized content type.
-// If no authorized content type found, throws an error.
-func CheckAuthorizedContentType(h http.Header) error {
-	ct := findContentType(h.Get("Content-Type"), MultipartFormDataContentType)
-	if ct == "" {
-		return &notAuthorizedContentTypeError{}
-	}
-
-	return nil
-}
-
-// findContentType parses a string representing a content type and tries to find
-// one of the given content types.
-func findContentType(requestContentType string, contentTypes ...ContentType) ContentType {
-	for _, ct := range contentTypes {
-		if i := strings.IndexRune(requestContentType, ';'); i != -1 {
-			requestContentType = requestContentType[0:i]
-		}
-
-		if requestContentType == string(ct) {
-			return ct
-		}
-	}
-
-	return ""
-}

app/http/http_test.go

@@ -1,38 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestCheckAuthorizedContentType(t *testing.T) {
-	req := httptest.NewRequest(http.MethodPost, "/", nil)
-
-	// case 1: uses a request without a content type entry in its header.
-	if err := CheckAuthorizedContentType(req.Header); err == nil {
-		t.Error("Function should not have been able to retrieve an authorized content type from request's header")
-	}
-
-	// case 2: uses a request with a content type entry in its header.
-	req.Header.Set("Content-Type", string(MultipartFormDataContentType))
-	if err := CheckAuthorizedContentType(req.Header); err != nil {
-		t.Error("Function should have been able to retrieve an authorized content type from request's header")
-	}
-
-	// case 3: uses a request with a composed content type entry in its header.
-	req.Header.Set("Content-Type", "multipart/form-data; boundary=—-WebKitFormBoundary7MA4YWxkTrZu0gW")
-	if err := CheckAuthorizedContentType(req.Header); err != nil {
-		t.Error("Function should have been able to retrieve an authorized content type from request's header")
-	}
-
-}
-
-func TestNotAuthorizedContentTypeError(t *testing.T) {
-	err := &notAuthorizedContentTypeError{}
-	expected := fmt.Sprintf("Accepted value for 'Content-Type': %s", MultipartFormDataContentType)
-	if err.Error() != expected {
-		t.Errorf("Error returned a wrong message: got '%s' want '%s'", err.Error(), expected)
-	}
-}

app/logger/logger.go

@@ -1,79 +0,0 @@
-// Package logger implements a simple wrapper of the logrus library.
-package logger
-
-import (
-	"os"
-
-	"github.com/sirupsen/logrus"
-)
-
-// logger wraps a logrus.Logger instance.
-type logger struct {
-	logger *logrus.Logger
-}
-
-// log is our logger instance used across the application.
-var log = newLogger()
-
-// newLogger instantiates a logger instance with default values.
-func newLogger() *logger {
-	l := &logger{
-		logger: logrus.New(),
-	}
-
-	l.logger.Out = os.Stdout
-	l.logger.Level = logrus.InfoLevel
-
-	return l
-}
-
-// SetLevel updates the level of messages which will be logged.
-func SetLevel(level logrus.Level) {
-	log.logger.SetLevel(level)
-}
-
-// SetFormatter updates the output format.
-// When a TTY is not attached, the output will be in the defined format.
-func SetFormatter(formatter logrus.Formatter) {
-	log.logger.Formatter = formatter
-}
-
-// Debug is a wrapper of the logrus Debug function.
-func Debug(message string) {
-	log.logger.Debug(message)
-}
-
-// Debugf is a wrapper of the logrus Debugf function.
-func Debugf(format string, args ...interface{}) {
-	log.logger.Debugf(format, args)
-}
-
-// Info is a wrapper of the logrus Info function.
-func Info(message string) {
-	log.logger.Info(message)
-}
-
-// Infof is a wrapper of the logrus Infof function.
-func Infof(format string, args ...interface{}) {
-	log.logger.Infof(format, args)
-}
-
-// Warn is a wrapper of the logrus Warn function.
-func Warn(message string) {
-	log.logger.Warn(message)
-}
-
-// Error is a wrapper of the logrus Error function.
-func Error(err error) {
-	log.logger.Error(err.Error())
-}
-
-// Fatal is a wrapper of the logrus Fatal function.
-func Fatal(err error) {
-	log.logger.Fatal(err.Error())
-}
-
-// Panic is a wrapper of the logrus Panic function.
-func Panic(err error) {
-	log.logger.Panic(err.Error())
-}

build/Dockerfile

@@ -0,0 +1,208 @@
+# ARG instructions do not create additional layers. Instead, next layers will
+# concatenate them. Also, we have to repeat ARG instructions in each build
+# stage that uses them.
+ARG GOLANG_VERSION
+
+# ----------------------------------------------
+# Gotenberg binary build stage
+# ----------------------------------------------
+FROM golang:$GOLANG_VERSION AS binary-stage
+
+ARG GOTENBERG_VERSION
+ENV CGO_ENABLED=0
+
+# Define the working directory outside of $GOPATH (we're using go modules).
+WORKDIR /home
+
+# Install module dependencies.
+COPY go.mod go.sum ./
+
+RUN go mod download &&\
+    go mod verify
+
+# Copy the source code.
+COPY cmd ./cmd
+COPY pkg ./pkg
+
+RUN go build -o gotenberg -ldflags "-X 'github.com/gotenberg/gotenberg/v8/cmd.Version=$GOTENBERG_VERSION'" cmd/gotenberg/main.go
+
+# ----------------------------------------------
+# Final stage
+# ----------------------------------------------
+FROM debian:12-slim
+
+ARG GOTENBERG_VERSION
+ARG GOTENBERG_USER_GID
+ARG GOTENBERG_USER_UID
+ARG NOTO_COLOR_EMOJI_VERSION
+ARG PDFTK_VERSION
+ARG TMP_CHOMIUM_VERSION_ARMHF="116.0.5845.180-1~deb12u1"
+
+LABEL org.opencontainers.image.title="Gotenberg" \
+      org.opencontainers.image.description="A Docker-powered stateless API for PDF files." \
+      org.opencontainers.image.version="$GOTENBERG_VERSION" \
+      org.opencontainers.image.authors="Julien Neuhart <neuhart.julien@gmail.com>" \
+      org.opencontainers.image.documentation="https://gotenberg.dev" \
+      org.opencontainers.image.source="https://github.com/gotenberg/gotenberg"
+
+RUN \
+    # Create a non-root user.
+    # All processes in the Docker container will run with this dedicated user.
+    groupadd --gid "$GOTENBERG_USER_GID" gotenberg &&\
+    useradd --uid "$GOTENBERG_USER_UID" --gid gotenberg --shell /bin/bash --home /home/gotenberg --no-create-home gotenberg &&\
+    mkdir /home/gotenberg &&\
+    chown gotenberg: /home/gotenberg
+
+RUN \
+    # Install system dependencies required for the next instructions or debugging.
+    # Note: tini is a helper for reaping zombie processes.
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends curl gnupg tini python3 default-jre-headless &&\
+    # Cleanup.
+    # Note: the Debian image does automatically a clean after each install thanks to a hook.
+    # Therefore, there is no need for apt-get clean.
+    # See https://stackoverflow.com/a/24417119/3248473.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install fonts.
+    # Credits:
+    # https://github.com/arachnys/athenapdf/blob/master/cli/Dockerfile.
+    # https://help.accusoft.com/PrizmDoc/v12.1/HTML/Installing_Asian_Fonts_on_Ubuntu_and_Debian.html.
+    curl -o ./ttf-mscorefonts-installer_3.8.1_all.deb http://httpredir.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.8.1_all.deb &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
+    ./ttf-mscorefonts-installer_3.8.1_all.deb \
+    culmus \
+    fonts-beng \
+    fonts-hosny-amiri \
+    fonts-lklug-sinhala \
+    fonts-lohit-guru \
+    fonts-lohit-knda \
+    fonts-samyak-gujr \
+    fonts-samyak-mlym \
+    fonts-samyak-taml \
+    fonts-sarai \
+    fonts-sil-abyssinica \
+    fonts-sil-padauk \
+    fonts-telu \
+    fonts-thai-tlwg \
+    ttf-wqy-zenhei \
+    fonts-arphic-ukai \
+    fonts-arphic-uming \
+    fonts-ipafont-mincho \
+    fonts-ipafont-gothic \
+    fonts-unfonts-core \
+    # LibreOffice recommends.
+    fonts-crosextra-caladea \
+    fonts-crosextra-carlito \
+    fonts-dejavu \
+    fonts-dejavu-extra \
+    fonts-liberation \
+    fonts-liberation2 \
+    fonts-linuxlibertine \
+    fonts-noto-cjk \
+    fonts-noto-core \
+    fonts-noto-mono \
+    fonts-noto-ui-core \
+    fonts-sil-gentium \
+    fonts-sil-gentium-basic &&\
+    rm -f ./ttf-mscorefonts-installer_3.8.1_all.deb &&\
+    # Add Color and Black-and-White Noto emoji font.
+    # Credits:
+    # https://github.com/gotenberg/gotenberg/pull/325.
+    # https://github.com/googlefonts/noto-emoji.
+    curl -Ls "https://github.com/googlefonts/noto-emoji/raw/$NOTO_COLOR_EMOJI_VERSION/fonts/NotoColorEmoji.ttf" -o /usr/local/share/fonts/NotoColorEmoji.ttf &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install either Google Chrome stable on amd64 architecture or
+    # Chromium on other architectures.
+    # See https://github.com/gotenberg/gotenberg/issues/328.
+    # FIXME:
+    # armhf is currently not working with the latest version of Chromium.
+    # See: https://github.com/gotenberg/gotenberg/issues/709.
+    /bin/bash -c \
+    'set -e &&\
+    if [[ "$(dpkg --print-architecture)" == "amd64" ]]; then \
+      curl https://dl.google.com/linux/linux_signing_key.pub | apt-key add - &&\
+      echo "deb http://dl.google.com/linux/chrome/deb/ stable main" | tee /etc/apt/sources.list.d/google-chrome.list &&\
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends --allow-unauthenticated google-chrome-stable &&\
+      mv /usr/bin/google-chrome-stable /usr/bin/chromium; \
+    elif [[ "$(dpkg --print-architecture)" == "armhf" ]]; then \
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends devscripts &&\
+      debsnap chromium-common "$TMP_CHOMIUM_VERSION_ARMHF" -v --force --binary --architecture armhf &&\
+      debsnap chromium "$TMP_CHOMIUM_VERSION_ARMHF" -v --force --binary --architecture armhf &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install --fix-broken -y -qq --no-install-recommends "./binary-chromium-common/chromium-common_${TMP_CHOMIUM_VERSION_ARMHF}_armhf.deb" "./binary-chromium/chromium_${TMP_CHOMIUM_VERSION_ARMHF}_armhf.deb" &&\
+      DEBIAN_FRONTEND=noninteractive apt-get purge -y -qq devscripts &&\
+      rm -rf ./binary-chromium-common/* ./binary-chromium/*; \
+    else \
+      apt-get update -qq &&\
+      DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends chromium; \
+    fi' &&\
+    # Verify installation.
+    chromium --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install LibreOffice & unoconverter.
+    echo "deb http://deb.debian.org/debian bookworm-backports main" >> /etc/apt/sources.list &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends -t bookworm-backports libreoffice &&\
+    curl -Ls https://raw.githubusercontent.com/gotenberg/unoconverter/v0.0.1/unoconv -o /usr/bin/unoconverter &&\
+    chmod +x /usr/bin/unoconverter &&\
+    # unoconverter will look for the Python binary, which has to be at version 3.
+    ln -s /usr/bin/python3 /usr/bin/python &&\
+    # Verify installations.
+    libreoffice --version &&\
+    unoconverter --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN \
+    # Install PDFtk, QPDF & ExifTool (PDF engines).
+    # See https://github.com/gotenberg/gotenberg/pull/273.
+    curl -o /usr/bin/pdftk-all.jar "https://gitlab.com/api/v4/projects/5024297/packages/generic/pdftk-java/$PDFTK_VERSION/pdftk-all.jar" &&\
+    chmod a+x /usr/bin/pdftk-all.jar &&\
+    echo '#!/bin/bash\n\nexec java -jar /usr/bin/pdftk-all.jar "$@"' > /usr/bin/pdftk && \
+    chmod +x /usr/bin/pdftk &&\
+    apt-get update -qq &&\
+    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends qpdf exiftool &&\
+    # See https://github.com/nextcloud/docker/issues/380.
+    mkdir -p /usr/share/man/man1 &&\
+    # Verify installations.
+    pdftk --version &&\
+    qpdf --version &&\
+    exiftool --version &&\
+    # Cleanup.
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Improve fonts subpixel hinting and smoothing.
+# Credits:
+# https://github.com/arachnys/athenapdf/issues/69.
+# https://github.com/arachnys/athenapdf/commit/ba25a8d80a25d08d58865519c4cd8756dc9a336d.
+COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf
+
+# Copy the Gotenberg binary from the binary stage.
+COPY --from=binary-stage /home/gotenberg /usr/bin/
+
+# Environment variables required by modules or else.
+ENV CHROMIUM_BIN_PATH=/usr/bin/chromium
+ENV LIBREOFFICE_BIN_PATH=/usr/lib/libreoffice/program/soffice.bin
+ENV UNOCONVERTER_BIN_PATH=/usr/bin/unoconverter
+ENV PDFTK_BIN_PATH=/usr/bin/pdftk
+ENV QPDF_BIN_PATH=/usr/bin/qpdf
+ENV EXIFTOOL_BIN_PATH=/usr/bin/exiftool
+
+USER gotenberg
+WORKDIR /home/gotenberg
+
+# Default API port.
+EXPOSE 3000
+
+ENTRYPOINT [ "/usr/bin/tini", "--" ]
+CMD [ "gotenberg" ]

build/Dockerfile.cloudrun

@@ -0,0 +1,14 @@
+ARG DOCKER_REGISTRY
+ARG DOCKER_REPOSITORY
+ARG GOTENBERG_VERSION
+
+FROM $DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION
+
+USER root
+
+# For security reasons, the non-root user gotenberg does not own the Tini binary by default.
+# However, some providers like Cloud Run from Google Cloud cannot start a Docker container in that case.
+# See https://github.com/gotenberg/gotenberg/issues/90#issuecomment-543551353.
+RUN chown gotenberg: /usr/bin/tini
+
+USER gotenberg

build/fonts.conf

@@ -0,0 +1,29 @@
+<?xml version='1.0'?>
+<!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
+<fontconfig>
+ <match target="font">
+  <edit mode="assign" name="rgba">
+   <const>rgb</const>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="hinting">
+   <bool>true</bool>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="hintstyle">
+   <const>hintslight</const>
+  </edit>
+ </match>
+ <match target="font">
+  <edit mode="assign" name="antialias">
+   <bool>true</bool>
+  </edit>
+ </match>
+  <match target="font">
+    <edit mode="assign" name="lcdfilter">
+      <const>lcddefault</const>
+    </edit>
+  </match>
+</fontconfig>

cmd/gotenberg.go

@@ -0,0 +1,158 @@
+package gotenbergcmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	flag "github.com/spf13/pflag"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+// See https://patorjk.com/software/taag/#p=display&f=Small%20Slant&t=Gotenberg.
+// Credits: https://github.com/labstack/echo/blob/v4.3.0/echo.go#L240.
+const banner = `
+  _____     __           __               
+ / ___/__  / /____ ___  / /  ___ _______ _
+/ (_ / _ \/ __/ -_) _ \/ _ \/ -_) __/ _ '/
+\___/\___/\__/\__/_//_/_.__/\__/_/  \_, / 
+                                   /___/
+
+A Docker-powered stateless API for PDF files.
+Version: %s
+-------------------------------------------------------
+`
+
+// Version is the... version of the Gotenberg application. We set it at the
+// build stage of the Docker image.
+var Version = "snapshot"
+
+// Run starts the Gotenberg application. Call this in the main of your program.
+func Run() {
+	fmt.Printf(banner, Version)
+	gotenberg.Version = Version
+
+	// Create the root FlagSet and adds the modules flags to it.
+	fs := flag.NewFlagSet("gotenberg", flag.ExitOnError)
+	fs.Duration("gotenberg-graceful-shutdown-duration", time.Duration(30)*time.Second, "Set the graceful shutdown duration")
+
+	descriptors := gotenberg.GetModuleDescriptors()
+	var modsInfo string
+	for _, desc := range descriptors {
+		fs.AddFlagSet(desc.FlagSet)
+		modsInfo += desc.ID + " "
+	}
+
+	fmt.Printf("[SYSTEM] modules: %s\n", modsInfo)
+
+	// Parse the flags...
+	err := fs.Parse(os.Args[1:])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// ...and create a wrapper around those.
+	parsedFlags := gotenberg.ParsedFlags{FlagSet: fs}
+
+	// Get the graceful shutdown duration.
+	gracefulShutdownDuration := parsedFlags.MustDuration("gotenberg-graceful-shutdown-duration")
+
+	ctx := gotenberg.NewContext(parsedFlags, descriptors)
+
+	// Start application modules.
+	apps, err := ctx.Modules(new(gotenberg.App))
+	if err != nil {
+		fmt.Printf("[FATAL] %s\n", err)
+		os.Exit(1)
+	}
+
+	for _, a := range apps {
+		go func(app gotenberg.App) {
+			id := app.(gotenberg.Module).Descriptor().ID
+			err = app.Start()
+			if err != nil {
+				fmt.Printf("[FATAL] starting %s: %s\n", id, err)
+				os.Exit(1)
+			}
+
+			startupMessage := app.StartupMessage()
+			if startupMessage == "" {
+				fmt.Printf("[SYSTEM] %s: application started\n", id)
+				return
+			}
+
+			fmt.Printf("[SYSTEM] %s: %s\n", id, startupMessage)
+		}(a.(gotenberg.App))
+	}
+
+	// Get modules that want to print system messages.
+	sysLoggers, err := ctx.Modules(new(gotenberg.SystemLogger))
+	if err != nil {
+		fmt.Printf("[FATAL] %s\n", err)
+		os.Exit(1)
+	}
+
+	for _, l := range sysLoggers {
+		go func(logger gotenberg.SystemLogger) {
+			id := logger.(gotenberg.Module).Descriptor().ID
+
+			for _, message := range logger.SystemMessages() {
+				fmt.Printf("[SYSTEM] %s: %s\n", id, message)
+			}
+		}(l.(gotenberg.SystemLogger))
+	}
+
+	quit := make(chan os.Signal, 1)
+
+	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C) or SIGTERM (Kubernetes).
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// Block until we receive our signal.
+	<-quit
+
+	gracefulShutdownCtx, cancel := context.WithTimeout(context.Background(), gracefulShutdownDuration)
+	defer cancel()
+
+	forceQuit := make(chan os.Signal, 1)
+	signal.Notify(forceQuit, syscall.SIGINT)
+
+	go func() {
+		// In case of force quit, cancel the context.
+		<-forceQuit
+		cancel()
+	}()
+
+	fmt.Printf("[SYSTEM] graceful shutdown of %s\n", gracefulShutdownDuration)
+
+	eg, _ := errgroup.WithContext(gracefulShutdownCtx)
+
+	for _, a := range apps {
+		eg.Go(func(app gotenberg.App) func() error {
+			return func() error {
+				id := app.(gotenberg.Module).Descriptor().ID
+
+				err = app.Stop(gracefulShutdownCtx)
+				if err != nil {
+					return fmt.Errorf("stopping %s: %w", id, err)
+				}
+
+				fmt.Printf("[SYSTEM] %s: application stopped\n", id)
+				return nil
+			}
+		}(a.(gotenberg.App)))
+	}
+
+	err = eg.Wait()
+	if err != nil {
+		fmt.Printf("[FATAL] %v\n", err)
+		os.Exit(1)
+	}
+
+	os.Exit(0)
+}

cmd/gotenberg/main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	gotenbergcmd "github.com/gotenberg/gotenberg/v8/cmd"
+	// Gotenberg modules.
+	_ "github.com/gotenberg/gotenberg/v8/pkg/standard"
+)
+
+func main() {
+	gotenbergcmd.Run()
+}

go.mod

@@ -0,0 +1,71 @@
+module github.com/gotenberg/gotenberg/v8
+
+go 1.23.0
+
+require (
+	github.com/alexliesenfeld/health v0.8.0
+	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/barasher/go-exiftool v1.10.0
+	github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f
+	github.com/chromedp/chromedp v0.10.0
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/uuid v1.6.0
+	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.7
+	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/klauspost/pgzip v1.2.6 // indirect
+	github.com/labstack/echo/v4 v4.12.0
+	github.com/labstack/gommon v0.4.2
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mholt/archiver/v3 v3.5.1
+	github.com/microcosm-cc/bluemonday v1.0.27
+	github.com/nwaples/rardecode v1.1.3 // indirect
+	github.com/pdfcpu/pdfcpu v0.8.1
+	github.com/pierrec/lz4/v4 v4.1.21 // indirect
+	github.com/prometheus/client_golang v1.20.4
+	github.com/russross/blackfriday/v2 v2.1.0
+	github.com/spf13/pflag v1.0.5
+	github.com/ulikunitz/xz v0.5.12 // indirect
+	go.uber.org/multierr v1.11.0
+	go.uber.org/zap v1.27.0
+	golang.org/x/crypto v0.27.0 // indirect
+	golang.org/x/image v0.20.0 // indirect
+	golang.org/x/net v0.29.0
+	golang.org/x/sync v0.8.0
+	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/term v0.24.0
+	golang.org/x/text v0.18.0
+)
+
+require github.com/dlclark/regexp2 v1.11.4
+
+require (
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.4.0 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
+	github.com/gorilla/css v1.0.1 // indirect
+	github.com/hhrutter/lzw v1.0.0 // indirect
+	github.com/hhrutter/tiff v1.0.1 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.59.1 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	golang.org/x/time v0.6.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+)

go.sum

@@ -0,0 +1,177 @@
+github.com/alexliesenfeld/health v0.8.0 h1:lCV0i+ZJPTbqP7LfKG7p3qZBl5VhelwUFCIVWl77fgk=
+github.com/alexliesenfeld/health v0.8.0/go.mod h1:TfNP0f+9WQVWMQRzvMUjlws4ceXKEL3WR+6Hp95HUFc=
+github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
+github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/barasher/go-exiftool v1.10.0 h1:f5JY5jc42M7tzR6tbL9508S2IXdIcG9QyieEXNMpIhs=
+github.com/barasher/go-exiftool v1.10.0/go.mod h1:F9s/a3uHSM8YniVfwF+sbQUtP8Gmh9nyzigNF+8vsWo=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chromedp/cdproto v0.0.0-20240801214329-3f85d328b335/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
+github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f h1:dEjjp+iN34En5Pl9XIi978DmR2/CMwuOxoPWtiHixKQ=
+github.com/chromedp/cdproto v0.0.0-20240919203636-12af5e8a671f/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
+github.com/chromedp/chromedp v0.10.0 h1:bRclRYVpMm/UVD76+1HcRW9eV3l58rFfy7AdBvKab1E=
+github.com/chromedp/chromedp v0.10.0/go.mod h1:ei/1ncZIqXX1YnAYDkxhD4gzBgavMEUu7JCKvztdomE=
+github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
+github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 h1:iFaUwBSo5Svw6L7HYpRu/0lE3e0BaElwnNO1qkNQxBY=
+github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5/go.mod h1:qssHWj60/X5sZFNxpG4HBPDHVqxNm4DfnCKgrbZOT+s=
+github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
+github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
+github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
+github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
+github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
+github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
+github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k=
+github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
+github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU=
+github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk=
+github.com/hhrutter/lzw v1.0.0 h1:laL89Llp86W3rRs83LvKbwYRx6INE8gDn0XNb1oXtm0=
+github.com/hhrutter/lzw v1.0.0/go.mod h1:2HC6DJSn/n6iAZfgM3Pg+cP1KxeWc3ezG8bBqW5+WEo=
+github.com/hhrutter/tiff v1.0.1 h1:MIus8caHU5U6823gx7C6jrfoEvfSTGtEFRiM8/LOzC0=
+github.com/hhrutter/tiff v1.0.1/go.mod h1:zU/dNgDm0cMIa8y8YwcYBeuEEveI4B0owqHyiPpJPHc=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
+github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0=
+github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
+github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
+github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
+github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
+github.com/nwaples/rardecode v1.1.3 h1:cWCaZwfM5H7nAD6PyEdcVnczzV8i/JtotnyW/dD9lEc=
+github.com/nwaples/rardecode v1.1.3/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
+github.com/pdfcpu/pdfcpu v0.8.1 h1:AiWUb8uXlrXqJ73OmiYXBjDF0Qxt4OuM281eAfkAOMA=
+github.com/pdfcpu/pdfcpu v0.8.1/go.mod h1:M5SFotxdaw0fedxthpjbA/PADytAo6wJnGH0SSBWJ7s=
+github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
+github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v1.20.4 h1:Tgh3Yr67PaOv/uTqloMsCEdeuFTatm5zIq5+qNN23vI=
+github.com/prometheus/client_golang v1.20.4/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.59.1 h1:LXb1quJHWm1P6wq/U824uxYi4Sg0oGvNeUm1z5dJoX0=
+github.com/prometheus/common v0.59.1/go.mod h1:GpWM7dewqmVYcd7SmRaiWVe9SSqjf0UrwnYnpEZNuT0=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
+github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
+github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
+golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
+golang.org/x/image v0.20.0 h1:7cVCUjQwfL18gyBJOmYvptfSHS8Fb3YUDtfLIZ7Nbpw=
+golang.org/x/image v0.20.0/go.mod h1:0a88To4CYVBAHp5FXJm8o7QbUl37Vd85ply1vyD8auM=
+golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
+golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
+golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U=
+golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,90 +0,0 @@
-/*
-Package main handles the application startup and shutdown.
-
-Gotenberg is a stateless API for converting Markdown files, HTML files and Office documents to PDF.
-
-For more information, go to https://github.com/thecodingmachine/gotenberg.
-*/
-package main
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/thecodingmachine/gotenberg/app"
-	"github.com/thecodingmachine/gotenberg/app/config"
-	"github.com/thecodingmachine/gotenberg/app/converter/process"
-	"github.com/thecodingmachine/gotenberg/app/logger"
-
-	"github.com/gorilla/mux"
-	"github.com/sirupsen/logrus"
-)
-
-// version will be set on build time.
-var version = "master"
-
-// defaultConfigurationFilePath is our default configuration file to parse.
-const defaultConfigurationFilePath = "gotenberg.yml"
-
-// main initializes the application, starts it, and handles
-// graceful shutdown.
-func main() {
-	c, err := config.NewAppConfig(defaultConfigurationFilePath)
-	if err != nil {
-		logger.SetLevel(logrus.InfoLevel)
-		logger.Fatal(err)
-		os.Exit(1)
-	}
-
-	// defines our application logging.
-	logger.SetLevel(c.Logs.Level)
-	logger.SetFormatter(c.Logs.Formatter)
-
-	// defines our application router.
-	r := mux.NewRouter()
-	r.Handle("/", app.GetHandlersChain()).Methods(http.MethodPost)
-
-	// defines our server.
-	s := &http.Server{
-		Addr:    fmt.Sprintf(":%s", c.Port),
-		Handler: r,
-	}
-
-	process.Load(c.CommandsConfig)
-	logger.Infof("Starting Gotenberg version %s", version)
-	logger.Infof("Listening on port %s", c.Port)
-
-	// runs our server in a goroutine so that it doesn't block.
-	go func() {
-		if err = s.ListenAndServe(); err != nil {
-			logger.SetLevel(logrus.InfoLevel)
-			logger.Panic(err)
-			os.Exit(1)
-		}
-	}()
-
-	quit := make(chan os.Signal, 1)
-	// we'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
-	// SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
-	signal.Notify(quit, os.Interrupt)
-
-	// blocks until we receive our signal.
-	<-quit
-
-	// creates a deadline to wait for.
-	var wait time.Duration
-	ctx, cancel := context.WithTimeout(context.Background(), wait)
-	defer cancel()
-
-	// doesn't block if no connections, but will otherwise wait
-	// until the timeout deadline.
-	s.Shutdown(ctx)
-
-	logger.SetLevel(logrus.InfoLevel)
-	logger.Info("Bye!")
-	os.Exit(0)
-}

orbit-payload.yml

@@ -1,7 +0,0 @@
-payload:
-
-  - key: Version
-    value: snapshot
-
-  - key: Latest
-    value: 1.0.0

orbit.yml

@@ -1,29 +0,0 @@
-tasks:
-  
-  - use: fmt
-    short: Runs go fmt ./...
-    run:
-      - go fmt ./...
-
-  - use: generate
-    short: Generates all files from blueprints
-    run:
-      - BRANCH="$(git symbolic-ref --short HEAD)"; orbit generate -f .blueprints/README.blueprint.md -o README.md -p "Branch,${BRANCH}"
-      - orbit generate -f .blueprints/Dockerfile.blueprint -o Dockerfile.ci -p "Image,CI"
-      - orbit generate -f .blueprints/Dockerfile.blueprint -o Dockerfile -p "Image,MAIN"
-
-  - use: ci
-    short: Runs CI process inside a container
-    run:
-      - docker build -t thecodingmachine/gotenberg:ci -f Dockerfile.ci .
-      - docker run --rm -e "VERSION={{ .Orbit.Version }}" -v "$(pwd)/.ci:/go/src/github.com/thecodingmachine/gotenberg/.ci" thecodingmachine/gotenberg:ci
-
-  - use: build
-    short: Builds the main Docker image
-    run:
-      - docker build . -t thecodingmachine/gotenberg:{{ .Orbit.Version }}
-
-  - use: up
-    short: Starts the {{ .Orbit.Version }} version of the Gotenberg image
-    run:
-      - docker run --rm -p 3000:3000/tcp thecodingmachine/gotenberg:{{ .Orbit.Version }}

pkg/gotenberg/cmd.go

@@ -0,0 +1,210 @@
+package gotenberg
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	"go.uber.org/zap"
+)
+
+// Cmd wraps an [exec.Cmd].
+type Cmd struct {
+	ctx     context.Context
+	logger  *zap.Logger
+	process *exec.Cmd
+}
+
+// Command creates a [Cmd] without a context. It configures the internal
+// [exec.Cmd] of [Cmd] so that we may kill its unix process and all its
+// children without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func Command(logger *zap.Logger, binPath string, args ...string) *Cmd {
+	cmd := exec.Command(binPath, args...)
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	return &Cmd{
+		ctx:     nil,
+		logger:  logger.Named(strings.ReplaceAll(binPath, "/", "")),
+		process: cmd,
+	}
+}
+
+// CommandContext creates a [Cmd] with a context. It configures the internal
+// [exec.Cmd] of [Cmd] so that we may kill its unix process and all its
+// children without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func CommandContext(ctx context.Context, logger *zap.Logger, binPath string, args ...string) (*Cmd, error) {
+	if ctx == nil {
+		return nil, errors.New("nil context")
+	}
+
+	cmd := exec.CommandContext(ctx, binPath, args...)
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	return &Cmd{
+		ctx:     ctx,
+		logger:  logger.Named(strings.ReplaceAll(binPath, "/", "")),
+		process: cmd,
+	}, nil
+}
+
+// Start starts the command but does not wait for its completion.
+func (cmd *Cmd) Start() error {
+	err := cmd.pipeOutput()
+	if err != nil {
+		return fmt.Errorf("pipe unix process output: %w", err)
+	}
+
+	cmd.logger.Debug(fmt.Sprintf("start unix process: %s", strings.Join(cmd.process.Args, " ")))
+
+	err = cmd.process.Start()
+	if err != nil {
+		return fmt.Errorf("start unix process: %w", err)
+	}
+
+	return nil
+}
+
+// Wait waits for the command to complete. It should be called when using the
+// Start method, so that the command does not leak zombies.
+func (cmd *Cmd) Wait() error {
+	err := cmd.process.Wait()
+	if err != nil {
+		return fmt.Errorf("wait for unix process: %w", err)
+	}
+
+	return nil
+}
+
+// Exec executes the command and wait for its completion or until the context
+// is done. In any case, it kills the unix process and all its children.
+func (cmd *Cmd) Exec() (int, error) {
+	if cmd.ctx == nil {
+		return 10, errors.New("nil context")
+	}
+
+	err := cmd.Start()
+	if err != nil {
+		if cmd.process.ProcessState == nil {
+			return 131, fmt.Errorf("start command: %w", err)
+		}
+
+		return cmd.process.ProcessState.ExitCode(), fmt.Errorf("start command: %w", err)
+	}
+
+	errChan := make(chan error, 1)
+
+	go func() {
+		errChan <- cmd.Wait()
+	}()
+
+	select {
+	case err = <-errChan:
+		errProc := cmd.Kill()
+		if errProc != nil {
+			cmd.logger.Error(errProc.Error())
+		}
+
+		if err == nil {
+			return 0, nil
+		}
+
+		if cmd.process.ProcessState == nil {
+			return 131, fmt.Errorf("unix process error: %w", err)
+		}
+
+		return cmd.process.ProcessState.ExitCode(), fmt.Errorf("unix process error: %w", err)
+	case <-cmd.ctx.Done():
+		errProc := cmd.Kill()
+		if errProc != nil {
+			cmd.logger.Error(errProc.Error())
+		}
+
+		return 62, fmt.Errorf("context done: %w", cmd.ctx.Err())
+	}
+}
+
+// pipeOutput creates logs entries according to the process stdout and stderr.
+// It does nothing if the logging level is not debug.
+func (cmd *Cmd) pipeOutput() error {
+	checkedEntry := cmd.logger.Check(zap.DebugLevel, "check for debug level before piping unix process output")
+	if checkedEntry == nil {
+		return nil
+	}
+
+	stdout, err := cmd.process.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("pipe unix process stdout: %w", err)
+	}
+
+	stderr, err := cmd.process.StderrPipe()
+	if err != nil {
+		return fmt.Errorf("unix process sdterr: %w", err)
+	}
+
+	// logCommandOutput creates logs entries according to a reader
+	// (either stdout or stderr).
+	logCommandOutput := func(logger *zap.Logger, reader io.ReadCloser) {
+		r := bufio.NewReader(reader)
+		defer func(reader io.ReadCloser) {
+			err := reader.Close()
+			if err != nil && !strings.Contains(err.Error(), "file already closed") {
+				logger.Error(fmt.Sprintf("close reader: %s", err))
+			}
+		}(reader)
+
+		for {
+			line, _, err := r.ReadLine()
+			if err != nil {
+				if err != io.EOF && !strings.Contains(err.Error(), "file already closed") {
+					logger.Error(fmt.Sprintf("pipe unix process output error: %s", err))
+				}
+
+				break
+			}
+
+			if len(line) != 0 {
+				logger.Debug(string(line))
+			}
+		}
+	}
+
+	go logCommandOutput(cmd.logger.Named("stdout"), stdout)
+	go logCommandOutput(cmd.logger.Named("stderr"), stderr)
+
+	return nil
+}
+
+// Kill kills the unix process and all its children without creating orphans.
+//
+// See https://medium.com/@felixge/killing-a-child-process-and-all-of-its-children-in-go-54079af94773.
+func (cmd *Cmd) Kill() error {
+	if cmd.process == nil {
+		// We cannot use the logger here, because for whatever reason using it
+		// result to a panic.
+		// cmd.logger.Debug("no process, skip killing")
+		return nil
+	}
+
+	err := syscall.Kill(-cmd.process.Process.Pid, syscall.SIGKILL)
+	if err == nil {
+		cmd.logger.Debug("unix process killed")
+		return nil
+	}
+
+	// If the process does not exist anymore, the error is irrelevant.
+	if strings.Contains(err.Error(), "no such process") {
+		cmd.logger.Debug("unix process already killed")
+		return nil
+	}
+
+	return fmt.Errorf("kill unix process: %w", err)
+}

pkg/gotenberg/cmd_test.go

@@ -0,0 +1,306 @@
+package gotenberg
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+func TestCommand(t *testing.T) {
+	cmd := Command(zap.NewNop(), "foo")
+	if !cmd.process.SysProcAttr.Setpgid {
+		t.Error("expected cmd.process.SysProcAttr.Setpgid to be true")
+	}
+}
+
+func TestCommandContext(t *testing.T) {
+	tests := []struct {
+		scenario                  string
+		ctx                       context.Context
+		expectCommandContextError bool
+	}{
+		{
+			scenario:                  "nominal behavior",
+			ctx:                       context.Background(),
+			expectCommandContextError: false,
+		},
+		{
+			scenario:                  "nil context",
+			ctx:                       nil,
+			expectCommandContextError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			cmd, err := CommandContext(tc.ctx, zap.NewNop(), "foo")
+
+			if err == nil && !cmd.process.SysProcAttr.Setpgid {
+				t.Fatal("expected cmd.process.SysProcAttr.Setpgid to be true")
+			}
+
+			if !tc.expectCommandContextError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectCommandContextError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_Start(t *testing.T) {
+	tests := []struct {
+		scenario         string
+		cmd              *Cmd
+		expectStartError bool
+	}{
+		{
+			scenario:         "nominal behavior",
+			cmd:              Command(zap.NewNop(), "echo", "Hello", "World"),
+			expectStartError: false,
+		},
+		{
+			scenario:         "start error",
+			cmd:              Command(zap.NewNop(), "foo"),
+			expectStartError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Start()
+
+			if !tc.expectStartError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectStartError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_Wait(t *testing.T) {
+	tests := []struct {
+		scenario        string
+		cmd             *Cmd
+		expectWaitError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
+				err := cmd.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectWaitError: false,
+		},
+		{
+			scenario:        "wait error",
+			cmd:             Command(zap.NewNop(), "echo", "Hello", "World"),
+			expectWaitError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Wait()
+
+			if !tc.expectWaitError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectWaitError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_Exec(t *testing.T) {
+	tests := []struct {
+		scenario        string
+		cmd             *Cmd
+		timeout         time.Duration
+		expectExecError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
+				cmd, err := CommandContext(context.Background(), zap.NewNop(), "echo", "Hello", "World")
+				if err != nil {
+					t.Fatalf("expected no error from CommandContext(), but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectExecError: false,
+		},
+		{
+			scenario:        "nil context",
+			cmd:             Command(zap.NewNop(), "echo", "Hello", "World"),
+			expectExecError: true,
+		},
+		{
+			scenario: "start error",
+			cmd: func() *Cmd {
+				cmd, err := CommandContext(context.Background(), zap.NewNop(), "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			expectExecError: true,
+		},
+		{
+			scenario:        "context done",
+			cmd:             Command(zap.NewNop(), "sleep", "2"),
+			timeout:         time.Duration(1) * time.Second,
+			expectExecError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.timeout > 0 {
+				ctx, cancel := context.WithTimeout(context.TODO(), tc.timeout)
+				defer cancel()
+
+				tc.cmd.ctx = ctx
+			}
+
+			_, err := tc.cmd.Exec()
+
+			if !tc.expectExecError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectExecError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_pipeOutput(t *testing.T) {
+	tests := []struct {
+		scenario              string
+		cmd                   *Cmd
+		run                   bool
+		expectPipeOutputError bool
+	}{
+		{
+			scenario:              "nominal behavior",
+			cmd:                   Command(zap.NewExample(), "echo", "Hello", "World"),
+			run:                   true,
+			expectPipeOutputError: false,
+		},
+		{
+			scenario:              "no debug, no pipe",
+			cmd:                   Command(zap.NewNop(), "echo", "Hello", "World"),
+			run:                   false,
+			expectPipeOutputError: false,
+		},
+		{
+			scenario: "stdout already piped",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
+				_, err := cmd.process.StdoutPipe()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			run:                   false,
+			expectPipeOutputError: true,
+		},
+		{
+			scenario: "stderr already piped",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewExample(), "echo", "Hello", "World")
+				_, err := cmd.process.StderrPipe()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+			run:                   false,
+			expectPipeOutputError: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.pipeOutput()
+
+			if tc.run {
+				errStart := tc.cmd.process.Start()
+				if errStart != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			}
+
+			if !tc.expectPipeOutputError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectPipeOutputError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestCmd_Kill(t *testing.T) {
+	tests := []struct {
+		scenario string
+		cmd      *Cmd
+	}{
+		{
+			scenario: "nominal behavior",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "sleep", "60")
+				err := cmd.process.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+		},
+		{
+			scenario: "no process",
+			cmd:      &Cmd{logger: zap.NewNop()},
+		},
+		{
+			scenario: "process already killed",
+			cmd: func() *Cmd {
+				cmd := Command(zap.NewNop(), "sleep", "60")
+				err := cmd.process.Start()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = cmd.Kill()
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return cmd
+			}(),
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.cmd.Kill()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}

pkg/gotenberg/context.go

@@ -0,0 +1,124 @@
+package gotenberg
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Context is a struct which helps to initialize modules. When provisioning, a
+// module may use the context to get other modules that it needs internally.
+type Context struct {
+	flags           ParsedFlags
+	descriptors     []ModuleDescriptor
+	moduleInstances map[string]interface{}
+}
+
+// NewContext creates a [Context].
+// In a module, prefer the [Provisioner] interface to get a [Context].
+func NewContext(
+	flags ParsedFlags,
+	descriptors []ModuleDescriptor,
+) *Context {
+	return &Context{
+		flags:           flags,
+		descriptors:     descriptors,
+		moduleInstances: make(map[string]interface{}),
+	}
+}
+
+// ParsedFlags returns the parsed flags.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		flags := ctx.ParsedFlags()
+//		m.foo = flags.RequiredString("foo")
+//	}
+func (ctx *Context) ParsedFlags() ParsedFlags {
+	return ctx.flags
+}
+
+// Module returns a module which satisfies the requested interface.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		mod, _ := ctx.Module(new(ModuleInterface))
+//		real := mod.(ModuleInterface)
+//	}
+//
+// If the module has not yet been initialized, this method
+// initializes it. Otherwise, returns the already initialized instance.
+func (ctx *Context) Module(kind interface{}) (interface{}, error) {
+	mods, err := ctx.Modules(kind)
+	if err != nil {
+		return nil, fmt.Errorf("get module: %w", err)
+	}
+
+	if len(mods) != 1 {
+		return nil, fmt.Errorf("expected to have one and only one %s module", kind)
+	}
+
+	return mods[0], nil
+}
+
+// Modules returns the list of modules which satisfies the requested interface.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		mods, _ := ctx.Modules(new(ModuleInterface))
+//		for _, mod := range mods {
+//			real := mod.(ModuleInterface)
+//			// ...
+//		}
+//	}
+//
+// If one or more modules have not yet been initialized, this method
+// initializes them. Otherwise, returns the already initialized instances.
+func (ctx *Context) Modules(kind interface{}) ([]interface{}, error) {
+	realKind := reflect.TypeOf(kind).Elem()
+
+	var mods []interface{}
+
+	for _, desc := range ctx.descriptors {
+		newInstance := desc.New()
+
+		if ok := reflect.TypeOf(newInstance).Implements(realKind); ok {
+			// The module implements the requested interface.
+			// We check if it has already been initialized.
+			instance, ok := ctx.moduleInstances[desc.ID]
+
+			if ok {
+				mods = append(mods, instance)
+			} else {
+				err := ctx.loadModule(desc.ID, newInstance)
+				if err != nil {
+					return nil, err
+				}
+
+				mods = append(mods, newInstance)
+			}
+		}
+	}
+
+	return mods, nil
+}
+
+// loadModule calls the Provision and/or Validate methods of the requested
+// module if it satisfies the [Provisioner] and/or [Validator] interfaces.
+func (ctx *Context) loadModule(id string, instance interface{}) error {
+	if prov, ok := instance.(Provisioner); ok {
+		// The instance can be provisioned.
+		err := prov.Provision(ctx)
+		if err != nil {
+			return fmt.Errorf("provision module %s: %w", id, err)
+		}
+	}
+
+	if validator, ok := instance.(Validator); ok {
+		// The instance can be validated.
+		err := validator.Validate()
+		if err != nil {
+			return fmt.Errorf("validate module %s: %w", id, err)
+		}
+	}
+
+	ctx.moduleInstances[id] = instance
+
+	return nil
+}

pkg/gotenberg/context_test.go

@@ -0,0 +1,234 @@
+package gotenberg
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNewContext(t *testing.T) {
+	if NewContext(ParsedFlags{}, nil) == nil {
+		t.Error("expected a non-nil value")
+	}
+}
+
+func TestContext_ParsedFlags(t *testing.T) {
+	ctx := NewContext(ParsedFlags{}, nil)
+
+	actual := ctx.ParsedFlags()
+	expect := ParsedFlags{}
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestContext_Module(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		mods        []ModuleDescriptor
+		kind        interface{}
+		expectError bool
+	}{
+		{
+			scenario: "module with error on provision",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: true,
+		},
+		{
+			scenario: "two modules instead of one",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
+				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, tc.mods)
+			_, err := ctx.Module(tc.kind)
+
+			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 TestContext_Modules(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		mods        []ModuleDescriptor
+		kind        interface{}
+		expectError bool
+	}{
+		{
+			scenario: "module with error on provision",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: true,
+		},
+		{
+			scenario: "success (module)",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
+				return []ModuleDescriptor{mod.Descriptor(), mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: false,
+		},
+		{
+			scenario: "success (one module)",
+			mods: func() []ModuleDescriptor {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return nil }
+
+				return []ModuleDescriptor{mod.Descriptor()}
+			}(),
+			kind:        new(Provisioner),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, tc.mods)
+			_, err := ctx.Modules(tc.kind)
+
+			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 TestContext_loadModule(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		instance    interface{}
+		expectError bool
+	}{
+		{
+			scenario: "module with error on provision",
+			instance: func() interface{} {
+				mod := &struct {
+					ModuleMock
+					ProvisionerMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ProvisionMock = func(ctx *Context) error { return errors.New("foo") }
+				return mod
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "module with error on validation",
+			instance: func() interface{} {
+				mod := &struct {
+					ModuleMock
+					ValidatorMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ValidateMock = func() error { return errors.New("foo") }
+				return mod
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			instance: func() interface{} {
+				mod := &struct {
+					ModuleMock
+					ValidatorMock
+				}{}
+				mod.DescriptorMock = func() ModuleDescriptor {
+					return ModuleDescriptor{ID: "foo", New: func() Module { return mod }}
+				}
+				mod.ValidateMock = func() error { return nil }
+
+				return mod
+			}(),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ctx := NewContext(ParsedFlags{}, nil)
+			err := ctx.loadModule("foo", tc.instance)
+
+			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/gotenberg/doc.go

@@ -0,0 +1,7 @@
+// Package gotenberg provides most of the logic of the module system.
+//
+// caddyserver/caddy, licensed under the Apache License 2.0, has significantly
+// inspired this module system.
+//
+// More details are available on https://caddyserver.com/.
+package gotenberg

pkg/gotenberg/env.go

@@ -0,0 +1,35 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+)
+
+// StringEnv retrieves the value of the environment variable named by the key.
+// If the variable is present in the environment and not empty, the value is
+// returned.
+func StringEnv(key string) (string, error) {
+	val, ok := os.LookupEnv(key)
+	if !ok {
+		return "", fmt.Errorf("environment variable '%s' does not exist", key)
+	}
+	if val == "" {
+		return "", fmt.Errorf("environment variable '%s' is empty", key)
+	}
+	return val, nil
+}
+
+// IntEnv relies on [StringEnv] and converts the values if it exists and is not
+// empty.
+func IntEnv(key string) (int, error) {
+	val, err := StringEnv(key)
+	if err != nil {
+		return 0, err
+	}
+	intVal, err := strconv.Atoi(val)
+	if err != nil {
+		return 0, fmt.Errorf("get int value of environment variable '%s': %w", key, err)
+	}
+	return intVal, nil
+}

pkg/gotenberg/env_test.go

@@ -0,0 +1,134 @@
+package gotenberg
+
+import (
+	"os"
+	"testing"
+)
+
+func TestStringEnv(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		key         string
+		setEnv      func()
+		expectVal   string
+		expectError bool
+	}{
+		{
+			scenario:    "non-existing environment variable",
+			key:         "NON_EXISTING",
+			expectVal:   "",
+			expectError: true,
+		},
+		{
+			scenario: "empty environment variable",
+			key:      "EMPTY_STRING",
+			setEnv: func() {
+				err := os.Setenv("EMPTY_STRING", "")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   "",
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			key:      "EXISTING_STRING_VALUE",
+			setEnv: func() {
+				err := os.Setenv("EXISTING_STRING_VALUE", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   "foo",
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.setEnv != nil {
+				tc.setEnv()
+			}
+
+			val, err := StringEnv(tc.key)
+
+			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.expectVal != val {
+				t.Errorf("expected value '%s' but got '%s'", tc.expectVal, val)
+			}
+		})
+	}
+}
+
+func TestIntEnv(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		key         string
+		setEnv      func()
+		expectVal   int
+		expectError bool
+	}{
+		{
+			scenario: "empty environment variable",
+			key:      "EMPTY_INT",
+			setEnv: func() {
+				err := os.Setenv("EMPTY_INT", "")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   0,
+			expectError: true,
+		},
+		{
+			scenario: "non-integer value",
+			key:      "NON_INTEGER",
+			setEnv: func() {
+				err := os.Setenv("NON_INTEGER", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   0,
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			key:      "EXISTING_INT_VALUE",
+			setEnv: func() {
+				err := os.Setenv("EXISTING_INT_VALUE", "123")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectVal:   123,
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.setEnv != nil {
+				tc.setEnv()
+			}
+
+			val, err := IntEnv(tc.key)
+
+			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.expectVal != val {
+				t.Errorf("expected value %d but got %d", tc.expectVal, val)
+			}
+		})
+	}
+}

pkg/gotenberg/filter.go

@@ -0,0 +1,53 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/dlclark/regexp2"
+)
+
+// ErrFiltered happens if a value is filtered by the [FilterDeadline] function.
+var ErrFiltered = errors.New("value filtered")
+
+// FilterDeadline checks if given value is allowed and not denied according to
+// regex patterns. It returns a [context.DeadlineExceeded] if it takes too long
+// to process.
+func FilterDeadline(allowed, denied *regexp2.Regexp, s string, deadline time.Time) error {
+	// FIXME: not ideal to compile everytime, but is there another way to create a clone?
+	if allowed.String() != "" {
+		allow := regexp2.MustCompile(allowed.String(), 0)
+		allow.MatchTimeout = time.Until(deadline)
+
+		ok, err := allow.MatchString(s)
+		if err != nil {
+			if time.Now().After(deadline) {
+				return context.DeadlineExceeded
+			}
+			return fmt.Errorf("'%s' cannot handle '%s': %w", allow.String(), s, err)
+		}
+		if !ok {
+			return fmt.Errorf("'%s' does not match the expression from the allowed list: %w", s, ErrFiltered)
+		}
+	}
+
+	if denied.String() != "" {
+		deny := regexp2.MustCompile(denied.String(), 0)
+		deny.MatchTimeout = time.Until(deadline)
+
+		ok, err := deny.MatchString(s)
+		if err != nil {
+			if time.Now().After(deadline) {
+				return context.DeadlineExceeded
+			}
+			return fmt.Errorf("'%s' cannot handle '%s': %w", deny.String(), s, err)
+		}
+		if ok {
+			return fmt.Errorf("'%s' matches the expression from the denied list: %w", s, ErrFiltered)
+		}
+	}
+
+	return nil
+}

pkg/gotenberg/filter_test.go

@@ -0,0 +1,83 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/dlclark/regexp2"
+)
+
+func TestFilterDeadline(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		allowed       *regexp2.Regexp
+		denied        *regexp2.Regexp
+		s             string
+		deadline      time.Time
+		expectError   bool
+		expectedError error
+	}{
+		{
+			scenario:      "DeadlineExceeded (allowed)",
+			allowed:       regexp2.MustCompile("foo", 0),
+			denied:        regexp2.MustCompile("", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(-1) * time.Hour),
+			expectError:   true,
+			expectedError: context.DeadlineExceeded,
+		},
+		{
+			scenario:      "ErrFiltered (allowed)",
+			allowed:       regexp2.MustCompile("foo", 0),
+			denied:        regexp2.MustCompile("", 0),
+			s:             "bar",
+			deadline:      time.Now().Add(time.Duration(5) * time.Second),
+			expectError:   true,
+			expectedError: ErrFiltered,
+		},
+		{
+			scenario:      "DeadlineExceeded (denied)",
+			allowed:       regexp2.MustCompile("", 0),
+			denied:        regexp2.MustCompile("foo", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(-1) * time.Hour),
+			expectError:   true,
+			expectedError: context.DeadlineExceeded,
+		},
+		{
+			scenario:      "ErrFiltered (denied)",
+			allowed:       regexp2.MustCompile("", 0),
+			denied:        regexp2.MustCompile("foo", 0),
+			s:             "foo",
+			deadline:      time.Now().Add(time.Duration(5) * time.Second),
+			expectError:   true,
+			expectedError: ErrFiltered,
+		},
+		{
+			scenario:    "success",
+			allowed:     regexp2.MustCompile("", 0),
+			denied:      regexp2.MustCompile("", 0),
+			s:           "foo",
+			deadline:    time.Now().Add(time.Duration(5) * time.Second),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := FilterDeadline(tc.allowed, tc.denied, tc.s, tc.deadline)
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected an error but got none")
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+		})
+	}
+}

pkg/gotenberg/flags.go

@@ -0,0 +1,220 @@
+package gotenberg
+
+import (
+	"time"
+
+	"github.com/dlclark/regexp2"
+	"github.com/labstack/gommon/bytes"
+	flag "github.com/spf13/pflag"
+)
+
+// ParsedFlags wraps a [flag.FlagSet] so that retrieving the typed values is
+// easier.
+type ParsedFlags struct {
+	*flag.FlagSet
+}
+
+// MustString returns the string value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustString(name string) string {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedString returns the string value of a deprecated flag if it was
+// explicitly set or the string value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustString(deprecated)
+	}
+
+	return f.MustString(newName)
+}
+
+// MustStringSlice returns the string slice value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustStringSlice(name string) []string {
+	val, err := f.GetStringSlice(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedStringSlice returns the string slice value of a deprecated
+// flag if it was explicitly set or the string slice value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedStringSlice(deprecated string, newName string) []string {
+	if f.Changed(deprecated) {
+		return f.MustStringSlice(deprecated)
+	}
+
+	return f.MustStringSlice(newName)
+}
+
+// MustBool returns the boolean value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustBool(name string) bool {
+	val, err := f.GetBool(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedBool returns the boolean value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedBool(deprecated string, newName string) bool {
+	if f.Changed(deprecated) {
+		return f.MustBool(deprecated)
+	}
+
+	return f.MustBool(newName)
+}
+
+// MustInt64 returns the int64 value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustInt64(name string) int64 {
+	val, err := f.GetInt64(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedInt64 returns the int64 value of a deprecated flag if it was
+// explicitly set or the int64 value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt64(deprecated string, newName string) int64 {
+	if f.Changed(deprecated) {
+		return f.MustInt64(deprecated)
+	}
+
+	return f.MustInt64(newName)
+}
+
+// MustInt returns the int value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustInt(name string) int {
+	val, err := f.GetInt(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedInt returns the int value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt(deprecated string, newName string) int {
+	if f.Changed(deprecated) {
+		return f.MustInt(deprecated)
+	}
+
+	return f.MustInt(newName)
+}
+
+// MustFloat64 returns the float value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustFloat64(name string) float64 {
+	val, err := f.GetFloat64(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedFloat64 returns the float value of a deprecated flag if it was
+// explicitly set or the float value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedFloat64(deprecated string, newName string) float64 {
+	if f.Changed(deprecated) {
+		return f.MustFloat64(deprecated)
+	}
+
+	return f.MustFloat64(newName)
+}
+
+// MustDuration returns the time.Duration value of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDuration(name string) time.Duration {
+	val, err := f.GetDuration(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedDuration returns the time.Duration value of a deprecated flag
+// if it was explicitly set or the time.Duration value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string) time.Duration {
+	if f.Changed(deprecated) {
+		return f.MustDuration(deprecated)
+	}
+
+	return f.MustDuration(newName)
+}
+
+// MustHumanReadableBytesString returns the human-readable bytes string of a
+// flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	_, err = bytes.Parse(val)
+	if err != nil {
+		panic(err)
+	}
+
+	return val
+}
+
+// MustDeprecatedHumanReadableBytesString returns the human-readable bytes
+// string of a deprecated flag if it was explicitly set or the human-readable
+// bytes string of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytesString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustHumanReadableBytesString(deprecated)
+	}
+
+	return f.MustHumanReadableBytesString(newName)
+}
+
+// MustRegexp returns the regular expression of a flag given by name.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustRegexp(name string) *regexp2.Regexp {
+	val, err := f.GetString(name)
+	if err != nil {
+		panic(err)
+	}
+
+	return regexp2.MustCompile(val, 0)
+}
+
+// MustDeprecatedRegexp returns the regular expression of a deprecated flag if
+// it was explicitly set or the regular expression of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedRegexp(deprecated string, newName string) *regexp2.Regexp {
+	if f.Changed(deprecated) {
+		return f.MustRegexp(deprecated)
+	}
+
+	return f.MustRegexp(newName)
+}

pkg/gotenberg/flags_test.go

@@ -0,0 +1,829 @@
+package gotenberg
+
+import (
+	"reflect"
+	"regexp"
+	"testing"
+	"time"
+
+	flag "github.com/spf13/pflag"
+)
+
+func TestParsedFlags_MustString(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "", "")
+
+	err := fs.Parse([]string{"--foo=foo"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustString(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedString(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: "foo",
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: "bar",
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: "foo",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedString("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustStringSlice(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.StringSlice("foo", make([]string, 0), "")
+
+	err := fs.Parse([]string{"--foo=foo", "--foo=bar", "--foo=baz"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustStringSlice(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedStringSlice(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue []string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: []string{"foo"},
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: []string{"bar"},
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: []string{"foo"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.StringSlice("foo", make([]string, 0), "")
+			fs.StringSlice("bar", make([]string, 0), "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedStringSlice("foo", "bar")
+			if !reflect.DeepEqual(actual, tc.expectValue) {
+				t.Errorf("expected %+v but got %+v", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustBool(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Bool("foo", false, "")
+
+	err := fs.Parse([]string{"--foo=true"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustBool(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedBool(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue bool
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=true"},
+			expectValue: true,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=false"},
+			expectValue: false,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=true", "--bar=false"},
+			expectValue: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Bool("foo", false, "")
+			fs.Bool("bar", true, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedBool("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %v but got %v", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustInt64(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Int64("foo", 0, "")
+
+	err := fs.Parse([]string{"--foo=1"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustInt64(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedInt64(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue int64
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Int64("foo", 0, "")
+		fs.Int64("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		actual := parsedFlags.MustDeprecatedInt64("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("expected %d but got %d", tc.expectValue, actual)
+		}
+	}
+}
+
+func TestParsedFlags_MustInt(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Int("foo", 0, "")
+
+	err := fs.Parse([]string{"--foo=1"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustInt(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedInt(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue int
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Int("foo", 0, "")
+			fs.Int("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedInt("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %d but got %d", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustFloat64(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Float64("foo", 1.0, "")
+
+	err := fs.Parse([]string{"--foo=2.0"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustFloat64(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedFloat64(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue float64
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1.0"},
+			expectValue: 1.0,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2.0"},
+			expectValue: 2.0,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1.0", "--bar=2.0"},
+			expectValue: 1.0,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Float64("foo", 0, "")
+			fs.Float64("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedFloat64("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected %f but got %f", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustDuration(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.Duration("foo", time.Duration(1)*time.Second, "")
+
+	err := fs.Parse([]string{"--foo=2m"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustDuration(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue time.Duration
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2s"},
+			expectValue: time.Duration(2) * time.Second,
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1s", "--bar=2s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.Duration("foo", 0, "")
+			fs.Duration("bar", 0, "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedDuration("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "1MB", "")
+	fs.String("bar", "1MB", "")
+
+	err := fs.Parse([]string{"--foo=1GB", "--bar=foo"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustHumanReadableBytesString(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=1MB"},
+			expectValue: "1MB",
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=2MB"},
+			expectValue: "2MB",
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
+			expectValue: "1MB",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+			if actual != tc.expectValue {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+			}
+		})
+	}
+}
+
+func TestParsedFlags_MustRegexp(t *testing.T) {
+	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+	fs.String("foo", "", "")
+	fs.String("bar", "", "")
+
+	err := fs.Parse([]string{"--foo=", "--bar=*"})
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	parsedFlags := ParsedFlags{FlagSet: fs}
+
+	for _, tc := range []struct {
+		scenario    string
+		name        string
+		expectPanic bool
+	}{
+		{
+			scenario:    "success",
+			name:        "foo",
+			expectPanic: false,
+		},
+		{
+			scenario:    "non-existing flag",
+			name:        "bar",
+			expectPanic: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Fatal("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			parsedFlags.MustRegexp(tc.name)
+		})
+	}
+}
+
+func TestParsedFlags_MustDeprecatedRegexp(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		rawFlags    []string
+		expectValue *regexp.Regexp
+	}{
+		{
+			scenario:    "deprecated flag value",
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+		{
+			scenario:    "non-deprecated flag value",
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: regexp.MustCompile("bar"),
+		},
+		{
+			scenario:    "deprecated flag value > non-deprecated flag value",
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+			fs.String("foo", "", "")
+			fs.String("bar", "", "")
+
+			parsedFlags := ParsedFlags{FlagSet: fs}
+
+			err := parsedFlags.Parse(tc.rawFlags)
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			actual := parsedFlags.MustDeprecatedRegexp("foo", "bar")
+			if actual.String() != tc.expectValue.String() {
+				t.Errorf("expected '%s' but got '%s'", tc.expectValue.String(), actual.String())
+			}
+		})
+	}
+}

pkg/gotenberg/fs.go

@@ -0,0 +1,61 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/google/uuid"
+)
+
+// FileSystem provides utilities for managing temporary directories. It creates
+// unique directory names based on UUIDs to ensure isolation of temporary files
+// for different modules.
+type FileSystem struct {
+	workingDir string
+}
+
+// NewFileSystem initializes a new [FileSystem] instance with a unique working
+// directory.
+func NewFileSystem() *FileSystem {
+	return &FileSystem{
+		workingDir: uuid.NewString(),
+	}
+}
+
+// WorkingDir returns the unique name of the working directory.
+func (fs *FileSystem) WorkingDir() string {
+	return fs.workingDir
+}
+
+// WorkingDirPath constructs and returns the full path to the working directory
+// inside the system's temporary directory.
+func (fs *FileSystem) WorkingDirPath() string {
+	return fmt.Sprintf("%s/%s", os.TempDir(), fs.workingDir)
+}
+
+// NewDirPath generates a new unique path for a directory inside the working
+// directory.
+func (fs *FileSystem) NewDirPath() string {
+	return fmt.Sprintf("%s/%s", fs.WorkingDirPath(), uuid.NewString())
+}
+
+// MkdirAll creates a new unique directory inside the working directory and
+// returns its path. If the directory creation fails, an error is returned.
+func (fs *FileSystem) MkdirAll() (string, error) {
+	path := fs.NewDirPath()
+
+	err := os.MkdirAll(path, 0o755)
+	if err != nil {
+		return "", fmt.Errorf("create directory %s: %w", path, err)
+	}
+
+	return path, nil
+}
+
+// PathRename defines the method signature for renaming files. Implement this
+// interface if you don't want to rely on [os.Rename], notably for testing
+// purpose.
+type PathRename interface {
+	// Rename uses the same signature as [os.Rename].
+	Rename(oldpath, newpath string) error
+}

pkg/gotenberg/fs_test.go

@@ -0,0 +1,55 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestFileSystem_WorkingDir(t *testing.T) {
+	fs := NewFileSystem()
+	dirName := fs.WorkingDir()
+
+	if dirName == "" {
+		t.Error("expected directory name but got empty string")
+	}
+}
+
+func TestFileSystem_WorkingDirPath(t *testing.T) {
+	fs := NewFileSystem()
+	expectedPath := fmt.Sprintf("%s/%s", os.TempDir(), fs.WorkingDir())
+
+	if fs.WorkingDirPath() != expectedPath {
+		t.Errorf("expected path '%s' but got '%s'", expectedPath, fs.WorkingDirPath())
+	}
+}
+
+func TestFileSystem_NewDirPath(t *testing.T) {
+	fs := NewFileSystem()
+	newDir := fs.NewDirPath()
+	expectedPrefix := fs.WorkingDirPath()
+
+	if !strings.HasPrefix(newDir, expectedPrefix) {
+		t.Errorf("expected new directory to start with '%s' but got '%s'", expectedPrefix, newDir)
+	}
+}
+
+func TestFileSystem_MkdirAll(t *testing.T) {
+	fs := NewFileSystem()
+
+	newPath, err := fs.MkdirAll()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	_, err = os.Stat(newPath)
+	if os.IsNotExist(err) {
+		t.Errorf("expected directory '%s' to exist but it doesn't", newPath)
+	}
+
+	err = os.RemoveAll(fs.WorkingDirPath())
+	if err != nil {
+		t.Fatalf("expected no error while cleaning up but got: %v", err)
+	}
+}

pkg/gotenberg/gc.go

@@ -0,0 +1,53 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go.uber.org/zap"
+)
+
+// GarbageCollect scans the root path and deletes files or directories with
+// names containing specific substrings.
+func GarbageCollect(logger *zap.Logger, rootPath string, includeSubstr []string) error {
+	logger = logger.Named("gc")
+
+	// To make sure that the next Walk method stays on
+	// the root level of the considered path, we have to
+	// return a filepath.SkipDir error if the current path
+	// is a directory.
+	skipDirOrNil := func(info os.FileInfo) error {
+		if info.IsDir() {
+			return filepath.SkipDir
+		}
+
+		return nil
+	}
+
+	return filepath.Walk(rootPath, func(path string, info os.FileInfo, pathErr error) error {
+		if pathErr != nil {
+			return pathErr
+		}
+
+		if path == rootPath {
+			return nil
+		}
+
+		for _, substr := range includeSubstr {
+			if strings.Contains(info.Name(), substr) || path == substr {
+				err := os.RemoveAll(path)
+				if err != nil {
+					return fmt.Errorf("garbage collect '%s': %w", path, err)
+				}
+
+				logger.Debug(fmt.Sprintf("'%s' removed", path))
+
+				return skipDirOrNil(info)
+			}
+		}
+
+		return skipDirOrNil(info)
+	})
+}

pkg/gotenberg/gc_test.go

@@ -0,0 +1,98 @@
+package gotenberg
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+)
+
+func TestGarbageCollect(t *testing.T) {
+	for _, tc := range []struct {
+		scenario        string
+		rootPath        string
+		includeSubstr   []string
+		expectError     bool
+		expectNotExists []string
+		expectExists    []string
+	}{
+		{
+			scenario:    "root path does not exist",
+			rootPath:    uuid.NewString(),
+			expectError: true,
+		},
+		{
+			scenario: "remove include substrings",
+			rootPath: func() string {
+				path := fmt.Sprintf("%s/a_directory", os.TempDir())
+
+				err := os.MkdirAll(path, 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_foo_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_bar_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_baz_file", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return path
+			}(),
+			includeSubstr:   []string{"foo", fmt.Sprintf("%s/a_directory/a_bar_file", os.TempDir())},
+			expectError:     false,
+			expectExists:    []string{"a_baz_file"},
+			expectNotExists: []string{"a_foo_file", "a_bar_file"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			defer func() {
+				err := os.RemoveAll(tc.rootPath)
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			err := GarbageCollect(zap.NewNop(), tc.rootPath, tc.includeSubstr)
+
+			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.expectError && err != nil {
+				return
+			}
+
+			for _, name := range tc.expectNotExists {
+				path := fmt.Sprintf("%s/%s", tc.rootPath, name)
+				_, err = os.Stat(path)
+				if !os.IsNotExist(err) {
+					t.Errorf("expected '%s' not to exist but it does: %v", path, err)
+				}
+			}
+
+			for _, name := range tc.expectExists {
+				path := fmt.Sprintf("%s/%s", tc.rootPath, name)
+				_, err = os.Stat(path)
+				if os.IsNotExist(err) {
+					t.Errorf("expected '%s' to exist but it does not: %v", path, err)
+				}
+			}
+		})
+	}
+}

pkg/gotenberg/logging.go

@@ -0,0 +1,57 @@
+package gotenberg
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"go.uber.org/zap"
+)
+
+// LoggerProvider is an interface for a module that supplies a method for
+// creating a [zap.Logger] instance for use by other modules.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.LoggerProvider))
+//		logger, _   := provider.(gotenberg.LoggerProvider).Logger(m)
+//	}
+type LoggerProvider interface {
+	Logger(mod Module) (*zap.Logger, error)
+}
+
+// LeveledLogger is wrapper around a [zap.Logger] so that it may be used by a
+// [retryablehttp.Client].
+type LeveledLogger struct {
+	logger *zap.Logger
+}
+
+// NewLeveledLogger instantiates a [LeveledLogger].
+func NewLeveledLogger(logger *zap.Logger) *LeveledLogger {
+	return &LeveledLogger{
+		logger: logger,
+	}
+}
+
+// Error logs a message at error level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Error(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Warn logs a message at warning level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Warn(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Info logs a message at info level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Info(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Debug logs a message at debug level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Debug(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Interface guards.
+var (
+	_ retryablehttp.LeveledLogger = (*LeveledLogger)(nil)
+)

pkg/gotenberg/logging_test.go

@@ -0,0 +1,23 @@
+package gotenberg
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestLeveledLogger_Error(t *testing.T) {
+	NewLeveledLogger(zap.NewNop()).Error("foo")
+}
+
+func TestLeveledLogger_Warn(t *testing.T) {
+	NewLeveledLogger(zap.NewNop()).Warn("foo")
+}
+
+func TestLeveledLogger_Info(t *testing.T) {
+	NewLeveledLogger(zap.NewNop()).Info("foo")
+}
+
+func TestLeveledLogger_Debug(t *testing.T) {
+	NewLeveledLogger(zap.NewNop()).Debug("foo")
+}

pkg/gotenberg/metrics.go

@@ -0,0 +1,26 @@
+package gotenberg
+
+// Metric represents a unitary metric.
+type Metric struct {
+	// Name is the unique identifier.
+	// Required.
+	Name string
+
+	// Description describes the metric.
+	// Optional.
+	Description string
+
+	// Read returns the current value.
+	// Required.
+	Read func() float64
+}
+
+// MetricsProvider is a module interface which provides a list of [Metric].
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.MetricsProvider))
+//		metrics, _  := provider.(gotenberg.MetricsProvider).Metrics()
+//	}
+type MetricsProvider interface {
+	Metrics() ([]Metric, error)
+}

pkg/gotenberg/mocks.go

@@ -0,0 +1,159 @@
+package gotenberg
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+)
+
+// ModuleMock is a mock for the [Module] interface.
+type ModuleMock struct {
+	DescriptorMock func() ModuleDescriptor
+}
+
+func (mod *ModuleMock) Descriptor() ModuleDescriptor {
+	return mod.DescriptorMock()
+}
+
+// ProvisionerMock is a mock for the [Provisioner] interface.
+type ProvisionerMock struct {
+	ProvisionMock func(*Context) error
+}
+
+func (mod *ProvisionerMock) Provision(ctx *Context) error {
+	return mod.ProvisionMock(ctx)
+}
+
+// ValidatorMock is a mock for the [Validator] interface.
+type ValidatorMock struct {
+	ValidateMock func() error
+}
+
+func (mod *ValidatorMock) Validate() error {
+	return mod.ValidateMock()
+}
+
+// PdfEngineMock is a mock for the [PdfEngine] interface.
+type PdfEngineMock struct {
+	MergeMock         func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
+	ConvertMock       func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
+	ReadMetadataMock  func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error)
+	WriteMetadataMock func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error
+}
+
+func (engine *PdfEngineMock) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+	return engine.MergeMock(ctx, logger, inputPaths, outputPath)
+}
+
+func (engine *PdfEngineMock) Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
+	return engine.ConvertMock(ctx, logger, formats, inputPath, outputPath)
+}
+
+func (engine *PdfEngineMock) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+	return engine.ReadMetadataMock(ctx, logger, inputPath)
+}
+
+func (engine *PdfEngineMock) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+	return engine.WriteMetadataMock(ctx, logger, metadata, inputPath)
+}
+
+// PdfEngineProviderMock is a mock for the [PdfEngineProvider] interface.
+type PdfEngineProviderMock struct {
+	PdfEngineMock func() (PdfEngine, error)
+}
+
+func (provider *PdfEngineProviderMock) PdfEngine() (PdfEngine, error) {
+	return provider.PdfEngineMock()
+}
+
+// ProcessMock is a mock for the [Process] interface.
+type ProcessMock struct {
+	StartMock   func(logger *zap.Logger) error
+	StopMock    func(logger *zap.Logger) error
+	HealthyMock func(logger *zap.Logger) bool
+}
+
+func (p *ProcessMock) Start(logger *zap.Logger) error {
+	return p.StartMock(logger)
+}
+
+func (p *ProcessMock) Stop(logger *zap.Logger) error {
+	return p.StopMock(logger)
+}
+
+func (p *ProcessMock) Healthy(logger *zap.Logger) bool {
+	return p.HealthyMock(logger)
+}
+
+// ProcessSupervisorMock is a mock for the [ProcessSupervisor] interface.
+type ProcessSupervisorMock struct {
+	LaunchMock        func() error
+	ShutdownMock      func() error
+	HealthyMock       func() bool
+	RunMock           func(ctx context.Context, logger *zap.Logger, task func() error) error
+	ReqQueueSizeMock  func() int64
+	RestartsCountMock func() int64
+}
+
+func (s *ProcessSupervisorMock) Launch() error {
+	return s.LaunchMock()
+}
+
+func (s *ProcessSupervisorMock) Shutdown() error {
+	return s.ShutdownMock()
+}
+
+func (s *ProcessSupervisorMock) Healthy() bool {
+	return s.HealthyMock()
+}
+
+func (s *ProcessSupervisorMock) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	return s.RunMock(ctx, logger, task)
+}
+
+func (s *ProcessSupervisorMock) ReqQueueSize() int64 {
+	return s.ReqQueueSizeMock()
+}
+
+func (s *ProcessSupervisorMock) RestartsCount() int64 {
+	return s.RestartsCountMock()
+}
+
+// LoggerProviderMock is a mock for the [LoggerProvider] interface.
+type LoggerProviderMock struct {
+	LoggerMock func(mod Module) (*zap.Logger, error)
+}
+
+func (provider *LoggerProviderMock) Logger(mod Module) (*zap.Logger, error) {
+	return provider.LoggerMock(mod)
+}
+
+// MetricsProviderMock is a mock for the [MetricsProvider] interface.
+type MetricsProviderMock struct {
+	MetricsMock func() ([]Metric, error)
+}
+
+func (provider *MetricsProviderMock) Metrics() ([]Metric, error) {
+	return provider.MetricsMock()
+}
+
+// PathRenameMock is a mock for the [PathRename] interface.
+type PathRenameMock struct {
+	RenameMock func(oldpath, newpath string) error
+}
+
+func (rename *PathRenameMock) Rename(oldpath, newpath string) error {
+	return rename.RenameMock(oldpath, newpath)
+}
+
+// Interface guards.
+var (
+	_ Module            = (*ModuleMock)(nil)
+	_ Validator         = (*ValidatorMock)(nil)
+	_ PdfEngine         = (*PdfEngineMock)(nil)
+	_ PdfEngineProvider = (*PdfEngineProviderMock)(nil)
+	_ Process           = (*ProcessMock)(nil)
+	_ ProcessSupervisor = (*ProcessSupervisorMock)(nil)
+	_ LoggerProvider    = (*LoggerProviderMock)(nil)
+	_ MetricsProvider   = (*MetricsProviderMock)(nil)
+)

pkg/gotenberg/mocks_test.go

@@ -0,0 +1,219 @@
+package gotenberg
+
+import (
+	"context"
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func TestModuleMock(t *testing.T) {
+	mock := &ModuleMock{
+		DescriptorMock: func() ModuleDescriptor {
+			return ModuleDescriptor{ID: "foo", New: func() Module {
+				return nil
+			}}
+		},
+	}
+
+	if mock.Descriptor().ID != "foo" {
+		t.Errorf("expected ID '%s' from ModuleMock.Descriptor, but got '%s'", "foo", mock.Descriptor().ID)
+	}
+}
+
+func TestProvisionerMock(t *testing.T) {
+	mock := &ProvisionerMock{
+		ProvisionMock: func(*Context) error {
+			return nil
+		},
+	}
+
+	err := mock.Provision(&Context{})
+	if err != nil {
+		t.Errorf("expected no error from ProvisionerMock.Provision, but got: %v", err)
+	}
+}
+
+func TestValidatorMock(t *testing.T) {
+	mock := &ValidatorMock{
+		ValidateMock: func() error {
+			return nil
+		},
+	}
+
+	err := mock.Validate()
+	if err != nil {
+		t.Errorf("expected no error from ValidatorMock.Validate, but got: %v", err)
+	}
+}
+
+func TestPDFEngineMock(t *testing.T) {
+	mock := &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 PdfFormats, inputPath, outputPath string) error {
+			return nil
+		},
+		ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+			return nil, nil
+		},
+		WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+			return nil
+		},
+	}
+
+	err := mock.Merge(context.Background(), zap.NewNop(), nil, "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.Merge, but got: %v", err)
+	}
+
+	err = mock.Convert(context.Background(), zap.NewNop(), PdfFormats{}, "", "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.Convert, but got: %v", err)
+	}
+
+	_, err = mock.ReadMetadata(context.Background(), zap.NewNop(), "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.ReadMetadata, but got: %v", err)
+	}
+
+	err = mock.WriteMetadata(context.Background(), zap.NewNop(), map[string]interface{}{}, "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.WriteMetadata but got: %v", err)
+	}
+}
+
+func TestPDFEngineProviderMock(t *testing.T) {
+	mock := &PdfEngineProviderMock{
+		PdfEngineMock: func() (PdfEngine, error) {
+			return new(PdfEngineMock), nil
+		},
+	}
+
+	_, err := mock.PdfEngine()
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineProviderMock.PdfEngine, but got: %v", err)
+	}
+}
+
+func TestProcessMock(t *testing.T) {
+	mock := &ProcessMock{
+		StartMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		StopMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		HealthyMock: func(logger *zap.Logger) bool {
+			return true
+		},
+	}
+
+	err := mock.Start(zap.NewNop())
+	if err != nil {
+		t.Errorf("expected no error from ProcessMock.Start, but got: %v", err)
+	}
+
+	err = mock.Stop(zap.NewNop())
+	if err != nil {
+		t.Errorf("expected no error from ProcessMock.Stop, but got: %v", err)
+	}
+
+	healthy := mock.Healthy(zap.NewNop())
+	if !healthy {
+		t.Error("expected true from ProcessMock.Healthy, but got false")
+	}
+}
+
+func TestProcessSupervisorMock(t *testing.T) {
+	mock := &ProcessSupervisorMock{
+		LaunchMock: func() error {
+			return nil
+		},
+		ShutdownMock: func() error {
+			return nil
+		},
+		HealthyMock: func() bool {
+			return true
+		},
+		RunMock: func(ctx context.Context, logger *zap.Logger, task func() error) error {
+			return nil
+		},
+		ReqQueueSizeMock: func() int64 {
+			return 0
+		},
+		RestartsCountMock: func() int64 {
+			return 0
+		},
+	}
+
+	err := mock.Launch()
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Launch, but got: %v", err)
+	}
+
+	err = mock.Shutdown()
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Shutdown, but got: %v", err)
+	}
+
+	healthy := mock.Healthy()
+	if !healthy {
+		t.Error("expected true from ProcessSupervisorMock.Healthy, but got false")
+	}
+
+	err = mock.Run(context.TODO(), zap.NewNop(), nil)
+	if err != nil {
+		t.Errorf("expected no error from ProcessSupervisorMock.Run, but got: %v", err)
+	}
+
+	size := mock.ReqQueueSize()
+	if size != 0 {
+		t.Errorf("expected 0 from ProcessSupervisorMock.ReqQueueSize, but got: %d", size)
+	}
+
+	restarts := mock.RestartsCount()
+	if restarts != 0 {
+		t.Errorf("expected 0 from ProcessSupervisorMock.RestartsCount, but got: %d", restarts)
+	}
+}
+
+func TestLoggerProviderMock(t *testing.T) {
+	mock := &LoggerProviderMock{
+		LoggerMock: func(mod Module) (*zap.Logger, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Logger(new(ModuleMock))
+	if err != nil {
+		t.Errorf("expected no error from LoggerProviderMock.Logger, but got: %v", err)
+	}
+}
+
+func TestMetricsProviderMock(t *testing.T) {
+	mock := &MetricsProviderMock{
+		MetricsMock: func() ([]Metric, error) {
+			return nil, nil
+		},
+	}
+
+	_, err := mock.Metrics()
+	if err != nil {
+		t.Errorf("expected no error from MetricsProviderMock.Metrics, but got: %v", err)
+	}
+}
+
+func TestPathRenameMock(t *testing.T) {
+	mock := &PathRenameMock{
+		RenameMock: func(oldpath, newpath string) error {
+			return nil
+		},
+	}
+
+	err := mock.Rename("", "")
+	if err != nil {
+		t.Errorf("expected no error from PathRenameMock.Rename, but got: %v", err)
+	}
+}

pkg/gotenberg/modules.go

@@ -0,0 +1,141 @@
+package gotenberg
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"sync"
+
+	flag "github.com/spf13/pflag"
+)
+
+// Module is a sort of plugin which adds new functionalities to the application
+// or other modules.
+//
+//	type YourModule struct {
+//		property string
+//	}
+//
+//	func (YourModule) Descriptor() gotenberg.ModuleDescriptor {
+//		return gotenberg.ModuleDescriptor{
+//			ID: "your_module",
+//			FlagSet: func() *flag.FlagSet {
+//				fs := flag.NewFlagSet("your_module", flag.ExitOnError)
+//				fs.String("your_module-property", "default value", "flag description")
+//
+//				return fs
+//			}(),
+//			New: func() gotenberg.Module { return new(YourModule) },
+//		}
+//	}
+type Module interface {
+	Descriptor() ModuleDescriptor
+}
+
+// ModuleDescriptor describes your module for the application.
+type ModuleDescriptor struct {
+	// ID is the unique name (snake case) of the module.
+	// Required.
+	ID string
+
+	// FlagSet is the definition of the flags of the module.
+	// Optional.
+	FlagSet *flag.FlagSet
+
+	// New returns a new and empty instance of the module's type.
+	// Required.
+	New func() Module
+}
+
+// Provisioner is a module interface for modules which have to be initialized
+// according to flags, environment variables, the context, etc.
+type Provisioner interface {
+	Provision(*Context) error
+}
+
+// Validator is a module interface for modules which have to be validated after
+// provisioning.
+type Validator interface {
+	Validate() error
+}
+
+// App is a module interface for modules which can be started or stopped by the
+// application.
+type App interface {
+	Start() error
+	// StartupMessage returns a custom message to display on startup. If it
+	// returns an empty string, a default startup message is used instead.
+	StartupMessage() string
+	Stop(ctx context.Context) error
+}
+
+// SystemLogger is a module interface for modules which want to display
+// messages on startup.
+type SystemLogger interface {
+	SystemMessages() []string
+}
+
+// MustRegisterModule registers a module.
+//
+// To register a module, create an init() method in the module main go file:
+//
+//	func init() {
+//		gotenberg.MustRegisterModule(YourModule{})
+//	}
+//
+// Then, in the main command (github.com/gotenberg/gotenberg/v8/cmd/gotenberg),
+// import the module:
+//
+//	imports (
+//		// Gotenberg modules.
+//		_ "your_module_path"
+//	)
+func MustRegisterModule(mod Module) {
+	desc := mod.Descriptor()
+
+	if desc.ID == "" {
+		panic("module with an empty ID cannot be registered")
+	}
+
+	if desc.New == nil {
+		panic("module New function cannot be nil")
+	}
+
+	if val := desc.New(); val == nil {
+		panic("module New function cannot return a nil instance")
+	}
+
+	descriptorsMu.Lock()
+	defer descriptorsMu.Unlock()
+
+	if _, ok := descriptors[desc.ID]; ok {
+		panic(fmt.Sprintf("module %s is already registered", desc.ID))
+	}
+
+	descriptors[desc.ID] = desc
+}
+
+// GetModuleDescriptors returns the descriptors of all registered modules.
+func GetModuleDescriptors() []ModuleDescriptor {
+	descriptorsMu.RLock()
+	defer descriptorsMu.RUnlock()
+
+	mods := make([]ModuleDescriptor, len(descriptors))
+	i := 0
+
+	for _, desc := range descriptors {
+		mods[i] = desc
+		i++
+	}
+
+	sort.Slice(mods, func(i, j int) bool {
+		return mods[i].ID < mods[j].ID
+	})
+
+	return mods
+}
+
+var (
+	descriptors   = make(map[string]ModuleDescriptor)
+	descriptorsMu sync.RWMutex
+)

pkg/gotenberg/modules_test.go

@@ -0,0 +1,107 @@
+package gotenberg
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestMustRegisterModule(t *testing.T) {
+	descriptorsMu.RLock()
+	descriptors = map[string]ModuleDescriptor{
+		"a": {ID: "a"},
+	}
+	descriptorsMu.RUnlock()
+
+	for _, tc := range []struct {
+		scenario    string
+		ID          string
+		New         func() Module
+		expectPanic bool
+	}{
+		{
+			scenario:    "no ID",
+			ID:          "",
+			New:         func() Module { return new(ModuleMock) },
+			expectPanic: true,
+		},
+		{
+			scenario:    "nil New method",
+			ID:          "b",
+			New:         nil,
+			expectPanic: true,
+		},
+		{
+			scenario:    "nil module",
+			ID:          "b",
+			New:         func() Module { return nil },
+			expectPanic: true,
+		},
+		{
+			scenario:    "existing module",
+			ID:          "a",
+			New:         func() Module { return new(ModuleMock) },
+			expectPanic: true,
+		},
+		{
+			scenario:    "success",
+			ID:          "b",
+			New:         func() Module { return new(ModuleMock) },
+			expectPanic: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := &struct{ ModuleMock }{}
+			mod.DescriptorMock = func() ModuleDescriptor { return ModuleDescriptor{ID: tc.ID, New: tc.New} }
+
+			if tc.expectPanic {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Error("expected panic but got none")
+					}
+				}()
+			}
+
+			if !tc.expectPanic {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Errorf("expected no panic but got: %v", r)
+					}
+				}()
+			}
+
+			MustRegisterModule(mod)
+		})
+	}
+
+	descriptorsMu.RLock()
+	descriptors = make(map[string]ModuleDescriptor)
+	descriptorsMu.RUnlock()
+}
+
+func TestGetModuleDescriptors(t *testing.T) {
+	descriptorsMu.RLock()
+	descriptors = map[string]ModuleDescriptor{
+		"d": {ID: "d"},
+		"c": {ID: "c"},
+		"b": {ID: "b"},
+		"a": {ID: "a"},
+	}
+	descriptorsMu.RUnlock()
+
+	expect := []ModuleDescriptor{
+		{ID: "a"},
+		{ID: "b"},
+		{ID: "c"},
+		{ID: "d"},
+	}
+
+	actual := GetModuleDescriptors()
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+
+	descriptorsMu.RLock()
+	descriptors = make(map[string]ModuleDescriptor)
+	descriptorsMu.RUnlock()
+}

pkg/gotenberg/pdfengine.go

@@ -0,0 +1,91 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+
+	"go.uber.org/zap"
+)
+
+var (
+	// ErrPdfEngineMethodNotSupported is returned when a specific method of the
+	// PdfEngine interface is not supported by its current implementation.
+	ErrPdfEngineMethodNotSupported = errors.New("method not supported")
+
+	// ErrPdfFormatNotSupported is returned when the Convert method of the
+	// PdfEngine interface does not support a requested PDF format conversion.
+	ErrPdfFormatNotSupported = errors.New("PDF format not supported")
+
+	// ErrPdfEngineMetadataValueNotSupported is returned when a metadata value
+	// is not supported.
+	ErrPdfEngineMetadataValueNotSupported = errors.New("metadata value not supported")
+)
+
+const (
+	// PdfA1a represents the PDF/A-1a format.
+	PdfA1a string = "PDF/A-1a"
+
+	// PdfA1b represents the PDF/A-1b format.
+	PdfA1b string = "PDF/A-1b"
+
+	// PdfA2a represents the PDF/A-2a format.
+	PdfA2a string = "PDF/A-2a"
+
+	// PdfA2b represents the PDF/A-2b format.
+	PdfA2b string = "PDF/A-2b"
+
+	// PdfA2u represents the PDF/A-2u format.
+	PdfA2u string = "PDF/A-2u"
+
+	// PdfA3a represents the PDF/A-3a format.
+	PdfA3a string = "PDF/A-3a"
+
+	// PdfA3b represents the PDF/A-3b format.
+	PdfA3b string = "PDF/A-3b"
+
+	// PdfA3u represents the PDF/A-3u format.
+	PdfA3u string = "PDF/A-3u"
+)
+
+// PdfFormats specifies the target formats for a PDF conversion.
+type PdfFormats struct {
+	// PdfA denotes the PDF/A standard format (e.g., PDF/A-1a).
+	PdfA string
+
+	// PdfUa indicates whether the PDF should comply
+	// with the PDF/UA (Universal Accessibility) standard.
+	PdfUa bool
+}
+
+// PdfEngine provides an interface for operations on PDFs. Implementations
+// can utilize various tools like PDFtk, or implement functionality directly in
+// Go.
+type PdfEngine interface {
+	// Merge combines multiple PDFs into a single PDF. The resulting page order
+	// is determined by the order of files provided in inputPaths.
+	Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
+
+	// Convert transforms a given PDF to the specified formats defined in
+	// PdfFormats. If no format, it does nothing.
+	Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
+
+	// ReadMetadata extracts the metadata of a given PDF file.
+	ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error)
+
+	// WriteMetadata writes the metadata into a given PDF file.
+	WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error
+}
+
+// PdfEngineProvider offers an interface to instantiate a [PdfEngine].
+// This is used to decouple the creation of a [PdfEngine] from its consumers.
+//
+// Example:
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.PdfEngineProvider))
+//		engine, _ := provider.(gotenberg.PdfEngineProvider).PdfEngine()
+//	}
+type PdfEngineProvider interface {
+	// PdfEngine returns an instance of the [PdfEngine] interface for PDF operations.
+	PdfEngine() (PdfEngine, error)
+}

pkg/gotenberg/sort.go

@@ -0,0 +1,69 @@
+package gotenberg
+
+import (
+	"regexp"
+	"sort"
+	"strconv"
+)
+
+// AlphanumericSort implements sort.Interface and helps to sort strings
+// alphanumerically.
+//
+// See: https://github.com/gotenberg/gotenberg/issues/805.
+type AlphanumericSort []string
+
+func (s AlphanumericSort) Len() int {
+	return len(s)
+}
+
+func (s AlphanumericSort) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s AlphanumericSort) Less(i, j int) bool {
+	numI, restI := extractPrefix(s[i])
+	numJ, restJ := extractPrefix(s[j])
+
+	// Compares numerical prefixes if they exist.
+	if numI != -1 && numJ != -1 {
+		if numI != numJ {
+			return numI < numJ
+		}
+		// If numbers are equal, falls back to string comparison of the rest.
+		return restI < restJ
+	}
+
+	// If one has a numerical prefix and the other doesn't, the one with the
+	// number comes first.
+	if numI != -1 {
+		return true
+	}
+	if numJ != -1 {
+		return false
+	}
+
+	// If neither has a numerical prefix, compare as strings
+	return s[i] < s[j]
+}
+
+// extractPrefix attempts to extract a numerical prefix and the rest of the filename
+func extractPrefix(filename string) (int, string) {
+	matches := numPrefixRegexp.FindStringSubmatch(filename)
+	if len(matches) > 2 {
+		prefix, err := strconv.Atoi(matches[1])
+		if err == nil {
+			return prefix, matches[2]
+		}
+	}
+
+	// Returns -1 if no numerical prefix is found, indicating to just compare
+	// as strings.
+	return -1, filename
+}
+
+var numPrefixRegexp = regexp.MustCompile(`^(\d+)(.*)$`)
+
+// Interface guard.
+var (
+	_ sort.Interface = (*AlphanumericSort)(nil)
+)

pkg/gotenberg/sort_test.go

@@ -0,0 +1,34 @@
+package gotenberg
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestAlphanumericSort(t *testing.T) {
+	for _, tc := range []struct {
+		scenario     string
+		values       []string
+		expectedSort []string
+	}{
+		{
+			scenario:     "numeric and letters",
+			values:       []string{"10qux.pdf", "2_baz.txt", "2_aza.txt", "1bar.pdf", "Afoo.txt", "Bbar.docx", "25zeta.txt", "3.pdf", "4_foo.pdf"},
+			expectedSort: []string{"1bar.pdf", "2_aza.txt", "2_baz.txt", "3.pdf", "4_foo.pdf", "10qux.pdf", "25zeta.txt", "Afoo.txt", "Bbar.docx"},
+		},
+		{
+			scenario:     "hrtime (PHP library)",
+			values:       []string{"245654773395259", "245654773395039", "245654773395149", "245654773394919", "245654773394369"},
+			expectedSort: []string{"245654773394369", "245654773394919", "245654773395039", "245654773395149", "245654773395259"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			sort.Sort(AlphanumericSort(tc.values))
+
+			if !reflect.DeepEqual(tc.values, tc.expectedSort) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedSort, tc.values)
+			}
+		})
+	}
+}

pkg/gotenberg/supervisor.go

@@ -0,0 +1,298 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+
+	"go.uber.org/zap"
+)
+
+// ErrProcessAlreadyRestarting happens if the [ProcessSupervisor] is trying
+// to restart an already restarting [Process].
+var ErrProcessAlreadyRestarting = errors.New("process already restarting")
+
+// ErrMaximumQueueSizeExceeded happens if Run() is called but the maximum queue
+// size is already used.
+var ErrMaximumQueueSizeExceeded = errors.New("maximum queue size exceeded")
+
+// Process is an interface that represents an abstract process
+// and provides methods for starting, stopping, and checking the health of the
+// process.
+//
+// Implementations of this interface should handle the actual logic for
+// starting, stopping, and ensuring the process's health.
+type Process interface {
+	// Start initiates the process and returns an error if the process cannot
+	// be started.
+	Start(logger *zap.Logger) error
+
+	// Stop terminates the process and returns an error if the process cannot
+	// be stopped.
+	Stop(logger *zap.Logger) error
+
+	// Healthy checks the health of the process. It returns true if the process
+	// is healthy; otherwise, it returns false.
+	Healthy(logger *zap.Logger) bool
+}
+
+// ProcessSupervisor provides methods to manage a [Process], including
+// starting, stopping, and ensuring its health.
+//
+// Additionally, it allows for the execution of tasks while managing the
+// process's state and provides functionality for limiting the number of
+// requests that can be handled by the process, as well as managing a request
+// queue.
+type ProcessSupervisor interface {
+	// Launch starts the managed [Process].
+	Launch() error
+
+	// Shutdown stops the managed [Process].
+	Shutdown() error
+
+	// Healthy checks and returns the health status of the managed [Process].
+	//
+	// If the process has not been started or is restarting, it is considered
+	// healthy and true is returned. Otherwise, it returns the health status of
+	// the actual process.
+	Healthy() bool
+
+	// Run executes a provided task while managing the state of the [Process].
+	//
+	// Run manages the request queue and may restart the process if it is not
+	// healthy or if the number of handled requests exceeds the maximum limit.
+	//
+	// It returns an error if the task cannot be run or if the process state
+	// cannot be managed properly.
+	Run(ctx context.Context, logger *zap.Logger, task func() error) error
+
+	// ReqQueueSize returns the current size of the request queue.
+	ReqQueueSize() int64
+
+	// RestartsCount returns the current number of restart.
+	RestartsCount() int64
+}
+
+type processSupervisor struct {
+	logger          *zap.Logger
+	process         Process
+	maxReqLimit     int64
+	maxQueueSize    int64
+	mutexChan       chan struct{}
+	firstStart      atomic.Bool
+	reqCounter      atomic.Int64
+	reqQueueSize    atomic.Int64
+	restartsCounter atomic.Int64
+	isRestarting    atomic.Bool
+}
+
+// NewProcessSupervisor initializes a new [ProcessSupervisor].
+func NewProcessSupervisor(logger *zap.Logger, process Process, maxReqLimit, maxQueueSize int64) ProcessSupervisor {
+	b := &processSupervisor{
+		logger:       logger,
+		process:      process,
+		mutexChan:    make(chan struct{}, 1),
+		maxReqLimit:  maxReqLimit,
+		maxQueueSize: maxQueueSize,
+	}
+	b.reqCounter.Store(0)
+	b.reqQueueSize.Store(0)
+	b.restartsCounter.Store(0)
+	b.isRestarting.Store(false)
+
+	return b
+}
+
+func (s *processSupervisor) Launch() error {
+	s.logger.Debug("start process")
+	err := s.process.Start(s.logger)
+	if err != nil {
+		return fmt.Errorf("start process: %w", err)
+	}
+
+	s.firstStart.Store(true)
+	s.logger.Debug("process successfully started")
+
+	return nil
+}
+
+func (s *processSupervisor) Shutdown() error {
+	s.logger.Debug("shutdown process")
+	err := s.process.Stop(s.logger)
+	if err != nil {
+		return fmt.Errorf("shutdown process: %w", err)
+	}
+
+	s.logger.Debug("process successfully shutdown")
+
+	return nil
+}
+
+func (s *processSupervisor) restart() error {
+	if s.isRestarting.Load() {
+		s.logger.Debug("process already restarting, skip restart")
+
+		return ErrProcessAlreadyRestarting
+	}
+
+	s.logger.Debug("restart process")
+	s.isRestarting.Store(true)
+	defer s.isRestarting.Store(false)
+
+	err := s.Shutdown()
+	if err != nil {
+		// No big deal? Chances are it's already stopped.
+		s.logger.Debug(fmt.Sprintf("stop process before restart: %s", err))
+	}
+
+	err = s.Launch()
+	if err != nil {
+		return fmt.Errorf("restart process: %w", err)
+	}
+
+	s.reqCounter.Store(0)
+	s.restartsCounter.Add(1)
+	s.logger.Debug("process successfully restarted")
+
+	return nil
+}
+
+func (s *processSupervisor) Healthy() bool {
+	if !s.firstStart.Load() {
+		// A non-started process is always healthy.
+		return true
+	}
+
+	if s.isRestarting.Load() {
+		// A restarting process is always healthy.
+		return true
+	}
+
+	return s.process.Healthy(s.logger)
+}
+
+func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	// A user reported a potential issue:
+	//
+	// "Although the counting operation is atomic, nothing prevent 2 concurrent
+	// goroutines to retrieve the same 'currentQueueSize' and to compare its
+	// value against the max limit. Then, resulting queue size would be 1 above
+	// the allowed limit."
+	//
+	// However, he was unable to actually trigger this issue, even when sending
+	// a lot of requests.
+	//
+	// For now, the best option is to consider this issue to be unlikely to
+	// happen, and keep the code as it is because it is more readable this way.
+	//
+	// See https://github.com/gotenberg/gotenberg/issues/951.
+	currentQueueSize := s.reqQueueSize.Load()
+	if s.maxQueueSize > 0 && currentQueueSize >= s.maxQueueSize {
+		return ErrMaximumQueueSizeExceeded
+	}
+
+	s.reqQueueSize.Add(1)
+
+	for {
+		err := func() error {
+			select {
+			case s.mutexChan <- struct{}{}:
+				logger.Debug("process lock acquired")
+				s.reqQueueSize.Add(-1)
+				s.reqCounter.Add(1)
+				releaseMutexChan := true
+
+				defer func() {
+					if releaseMutexChan {
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}
+				}()
+
+				if !s.firstStart.Load() {
+					err := s.runWithDeadline(ctx, func() error {
+						return s.Launch()
+					})
+					if err != nil {
+						return fmt.Errorf("process first start: %w", err)
+					}
+				}
+
+				if !s.Healthy() {
+					s.logger.Debug("process is unhealthy, cannot handle task, restarting...")
+					err := s.runWithDeadline(ctx, func() error {
+						return s.restart()
+					})
+					if err != nil {
+						return fmt.Errorf("process restart before task: %w", err)
+					}
+				}
+
+				err := s.runWithDeadline(ctx, task)
+
+				if s.maxReqLimit > 0 && s.reqCounter.Load() >= s.maxReqLimit {
+					s.logger.Debug("max request limit reached, restarting eagerly...")
+					releaseMutexChan = false
+
+					go func() {
+						err := s.runWithDeadline(context.Background(), func() error {
+							return s.restart()
+						})
+						if err != nil {
+							s.logger.Error(fmt.Sprintf("process restart after task: %v", err))
+						}
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}()
+				}
+
+				// Note: no error wrapping because it leaks on Chromium console exceptions output.
+				return err
+			case <-ctx.Done():
+				logger.Debug("failed to acquire process lock before deadline")
+				s.reqQueueSize.Add(-1)
+
+				return fmt.Errorf("acquire process lock: %w", ctx.Err())
+			}
+		}()
+
+		if errors.Is(err, ErrProcessAlreadyRestarting) {
+			logger.Debug("process is already restarting, trying to acquire process lock again...")
+			s.reqQueueSize.Add(1)
+			continue
+		}
+
+		// Note: no error wrapping because it leaks on Chromium console exceptions output.
+		return err
+	}
+}
+
+func (s *processSupervisor) runWithDeadline(ctx context.Context, task func() error) error {
+	runChan := make(chan error, 1)
+	go func() {
+		runChan <- task()
+	}()
+
+	for {
+		select {
+		case err := <-runChan:
+			return err
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func (s *processSupervisor) ReqQueueSize() int64 {
+	return s.reqQueueSize.Load()
+}
+
+func (s *processSupervisor) RestartsCount() int64 {
+	return s.restartsCounter.Load()
+}
+
+// Interface guards.
+var (
+	_ ProcessSupervisor = (*processSupervisor)(nil)
+)

pkg/gotenberg/supervisor_test.go

@@ -0,0 +1,639 @@
+package gotenberg
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+func TestProcessSupervisor_Launch(t *testing.T) {
+	for _, tc := range []struct {
+		scenario      string
+		startError    error
+		expectError   bool
+		firstStartSet bool
+	}{
+		{
+			scenario:      "successful launch",
+			startError:    nil,
+			expectError:   false,
+			firstStartSet: true,
+		},
+		{
+			scenario:      "failed launch",
+			startError:    errors.New("start error"),
+			expectError:   true,
+			firstStartSet: false,
+		},
+		{
+			scenario:      "process already started",
+			startError:    nil,
+			expectError:   false,
+			firstStartSet: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
+			if tc.firstStartSet {
+				ps.firstStart.Store(true)
+			}
+
+			err := ps.Launch()
+
+			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.firstStartSet && !ps.firstStart.Load() {
+				t.Error("expected firstStart to be set but it was not")
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Shutdown(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		stopError   error
+		expectError bool
+	}{
+		{
+			scenario:    "successful shutdown",
+			stopError:   nil,
+			expectError: false,
+		},
+		{
+			scenario:    "failed shutdown",
+			stopError:   errors.New("stop error"),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5, 0)
+			err := ps.Shutdown()
+
+			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 TestProcessSupervisor_restart(t *testing.T) {
+	for _, tc := range []struct {
+		scenario            string
+		initiallyRestarting bool
+		startError          error
+		stopError           error
+		expectError         bool
+		expectedError       error
+	}{
+		{
+			scenario:            "already restarting",
+			initiallyRestarting: true,
+			expectError:         true,
+			expectedError:       ErrProcessAlreadyRestarting,
+		},
+		{
+			scenario:    "successful restart",
+			startError:  nil,
+			stopError:   nil,
+			expectError: false,
+		},
+		{
+			scenario:    "failed to stop during restart",
+			startError:  nil,
+			stopError:   errors.New("stop error"),
+			expectError: false,
+		},
+		{
+			scenario:    "failed to start during restart",
+			startError:  errors.New("start error"),
+			stopError:   nil,
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
+			if tc.initiallyRestarting {
+				ps.isRestarting.Store(true)
+			}
+
+			err := ps.restart()
+
+			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.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Healthy(t *testing.T) {
+	for _, tc := range []struct {
+		scenario            string
+		initiallyStarted    bool
+		initiallyRestarting bool
+		processHealthy      bool
+		expectHealthy       bool
+	}{
+		{
+			scenario:         "non-started process is always healthy",
+			initiallyStarted: false,
+			expectHealthy:    true,
+		},
+		{
+			scenario:            "restarting process is always healthy",
+			initiallyStarted:    true,
+			initiallyRestarting: true,
+			expectHealthy:       true,
+		},
+		{
+			scenario:         "process reports as healthy",
+			initiallyStarted: true,
+			processHealthy:   true,
+			expectHealthy:    true,
+		},
+		{
+			scenario:         "process reports as unhealthy",
+			initiallyStarted: true,
+			processHealthy:   false,
+			expectHealthy:    false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				HealthyMock: func(logger *zap.Logger) bool {
+					return tc.processHealthy
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 5, 0).(*processSupervisor)
+			if tc.initiallyStarted {
+				ps.firstStart.Store(true)
+			}
+			if tc.initiallyRestarting {
+				ps.isRestarting.Store(true)
+			}
+
+			healthy := ps.Healthy()
+
+			if healthy != tc.expectHealthy {
+				t.Fatalf("expected healthy to be %v but got %v", tc.expectHealthy, healthy)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_Run(t *testing.T) {
+	for _, tc := range []struct {
+		scenario             string
+		initiallyStarted     bool
+		isRestarting         bool
+		startError           error
+		processHealthy       bool
+		maxReqLimit          int64
+		tasksToRun           int
+		taskError            error
+		expectError          bool
+		skipCallsCheck       bool
+		expectedStartCalls   int64
+		expectedHealthyCalls int64
+		expectedStopCalls    int64
+		currentQueueSize     int64
+		maxQueueSize         int64
+	}{
+		{
+			scenario:             "successfully run task on non-started process",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+		},
+		{
+			scenario:             "cannot launch non-started process",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			startError:           errors.New("launch error"),
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 0,
+			expectedStopCalls:    0,
+		},
+		{
+			scenario:             "run task with unhealthy process causing restart",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       false,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "cannot restart unhealthy process",
+			startError:           errors.New("start error"),
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       false,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:         "ErrProcessAlreadyRestarting",
+			initiallyStarted: true,
+			isRestarting:     true,
+			processHealthy:   false,
+			maxReqLimit:      1,
+			tasksToRun:       1,
+			expectError:      true,
+			skipCallsCheck:   true,
+		},
+		{
+			scenario:             "run tasks reaching max request limit causing restart",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           3,
+			expectError:          false,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 3,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "auto-restart after reaching max request limit",
+			startError:           errors.New("start error"),
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           2,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 2,
+			expectedStopCalls:    1,
+		},
+		{
+			scenario:             "task error",
+			initiallyStarted:     true,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          0,
+			tasksToRun:           1,
+			taskError:            errors.New("task error"),
+			expectError:          true,
+			expectedStartCalls:   0,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+		},
+		{
+			scenario:             "queue size exceeded",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   0,
+			expectedHealthyCalls: 0,
+			expectedStopCalls:    0,
+			currentQueueSize:     1,
+			maxQueueSize:         1,
+		},
+		{
+			scenario:             "queue size not exceeded",
+			initiallyStarted:     false,
+			isRestarting:         false,
+			processHealthy:       true,
+			maxReqLimit:          2,
+			tasksToRun:           1,
+			expectError:          true,
+			expectedStartCalls:   1,
+			expectedHealthyCalls: 1,
+			expectedStopCalls:    0,
+			currentQueueSize:     1,
+			maxQueueSize:         2,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			var startCalls, healthyCalls, stopCalls atomic.Int64
+			startCalls.Store(0)
+			healthyCalls.Store(0)
+			stopCalls.Store(0)
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					startCalls.Add(1)
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					stopCalls.Add(1)
+					return nil
+				},
+				HealthyMock: func(logger *zap.Logger) bool {
+					healthyCalls.Add(1)
+					return tc.processHealthy
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, tc.maxReqLimit, tc.maxQueueSize).(*processSupervisor)
+			if tc.initiallyStarted {
+				ps.firstStart.Store(true)
+			}
+			if tc.isRestarting {
+				ps.isRestarting.Store(true)
+			}
+			if tc.currentQueueSize > 0 {
+				ps.reqQueueSize.Store(tc.currentQueueSize)
+			}
+
+			task := func() error {
+				return tc.taskError
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+
+			var wg sync.WaitGroup
+			errorChan := make(chan error, tc.tasksToRun)
+
+			for i := 0; i < tc.tasksToRun; i++ {
+				wg.Add(1)
+				go func() {
+					defer wg.Done()
+					err := ps.Run(ctx, logger, task)
+					if err != nil {
+						errorChan <- err
+					}
+				}()
+			}
+
+			wg.Wait()
+			close(errorChan)
+
+			for err := range errorChan {
+				if tc.expectError && err == nil {
+					t.Fatal("expected an error but got none")
+				}
+
+				if !tc.expectError && err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			}
+
+			if tc.skipCallsCheck {
+				return
+			}
+
+			// Making sure restarts are finished.
+			ps.mutexChan <- struct{}{}
+			<-ps.mutexChan
+
+			if startCalls.Load() != tc.expectedStartCalls {
+				t.Errorf("expected %d process.Start calls, got %d", tc.expectedStartCalls, startCalls.Load())
+			}
+
+			if healthyCalls.Load() != tc.expectedHealthyCalls {
+				t.Errorf("expected %d process.Healthy calls, got %d", tc.expectedHealthyCalls, healthyCalls.Load())
+			}
+
+			if stopCalls.Load() != tc.expectedStopCalls {
+				t.Errorf("expected %d process.Stop calls, got %d", tc.expectedStopCalls, stopCalls.Load())
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_runWithDeadline(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctxDone     bool
+		expectError bool
+	}{
+		{
+			scenario:    "task finished",
+			ctxDone:     false,
+			expectError: false,
+		},
+		{
+			scenario:    "context expired",
+			ctxDone:     true,
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			ps := NewProcessSupervisor(zap.NewNop(), new(ProcessMock), 0, 0).(*processSupervisor)
+
+			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+			if tc.ctxDone {
+				cancel()
+			} else {
+				defer cancel()
+			}
+
+			err := ps.runWithDeadline(ctx, func() error {
+				return nil
+			})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected an error but got none")
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestProcessSupervisor_ReqQueueSize(t *testing.T) {
+	logger := zap.NewNop()
+	process := &ProcessMock{
+		StartMock: func(logger *zap.Logger) error {
+			return nil
+		},
+		HealthyMock: func(logger *zap.Logger) bool {
+			return true
+		},
+	}
+	ps := NewProcessSupervisor(logger, process, 0, 0).(*processSupervisor)
+
+	// Simulating a lock.
+	ps.mutexChan <- struct{}{}
+
+	if ps.ReqQueueSize() != 0 {
+		t.Fatalf("expected queue size to be 0 but got %d", ps.ReqQueueSize())
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	var wg sync.WaitGroup
+	errorChan := make(chan error, 10)
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			err := ps.Run(ctx, logger, func() error {
+				return nil
+			})
+			if err != nil {
+				errorChan <- err
+			}
+		}()
+	}
+
+	// We have to wait a little bit so that the request queue size may change.
+	time.Sleep(10 * time.Millisecond)
+
+	if ps.ReqQueueSize() != 10 {
+		t.Fatalf("expected queue size to be 10 but got %d", ps.ReqQueueSize())
+	}
+
+	wg.Wait()
+	close(errorChan)
+
+	for err := range errorChan {
+		if err == nil {
+			t.Error("expected a lock error but got none")
+		}
+	}
+
+	if ps.ReqQueueSize() != 0 {
+		t.Errorf("expected queue size to be 0 but got %d", ps.ReqQueueSize())
+	}
+}
+
+func TestProcessSupervisor_RestartsCount(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		initialRestartsCount  int64
+		restartAttempts       int
+		startError            error
+		stopError             error
+		expectedRestartsCount int64
+	}{
+		{
+			scenario:              "no restarts, counter remains 0",
+			initialRestartsCount:  0,
+			restartAttempts:       0,
+			expectedRestartsCount: 0,
+		},
+		{
+			scenario:              "successful restart increases counter",
+			initialRestartsCount:  0,
+			restartAttempts:       1,
+			startError:            nil,
+			stopError:             nil,
+			expectedRestartsCount: 1,
+		},
+		{
+			scenario:              "failed to stop during restart, no impact",
+			initialRestartsCount:  0,
+			restartAttempts:       1,
+			startError:            nil,
+			stopError:             errors.New("stop error"),
+			expectedRestartsCount: 1,
+		},
+		{
+			scenario:              "multiple successful restarts",
+			initialRestartsCount:  0,
+			restartAttempts:       3,
+			startError:            nil,
+			stopError:             nil,
+			expectedRestartsCount: 3,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			logger := zap.NewNop()
+
+			process := &ProcessMock{
+				StartMock: func(logger *zap.Logger) error {
+					return tc.startError
+				},
+				StopMock: func(logger *zap.Logger) error {
+					return tc.stopError
+				},
+			}
+
+			ps := NewProcessSupervisor(logger, process, 0, 0).(*processSupervisor)
+			ps.restartsCounter.Store(tc.initialRestartsCount)
+
+			for i := 0; i < tc.restartAttempts; i++ {
+				_ = ps.restart()
+			}
+
+			actualRestartsCount := ps.RestartsCount()
+			if actualRestartsCount != tc.expectedRestartsCount {
+				t.Fatalf("expected restarts count to be %d, but got  %d", tc.expectedRestartsCount, actualRestartsCount)
+			}
+		})
+	}
+}

pkg/gotenberg/version.go

@@ -0,0 +1,4 @@
+package gotenberg
+
+// Version is the... version of the Gotenberg application.
+var Version = "snapshot"

pkg/modules/api/api.go

@@ -0,0 +1,552 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/alexliesenfeld/health"
+	"github.com/dlclark/regexp2"
+	"github.com/labstack/echo/v4"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/multierr"
+	"go.uber.org/zap"
+	"golang.org/x/net/http2"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(new(Api))
+}
+
+// Api is a module which provides an HTTP server. Other modules may add routes,
+// middlewares or health checks.
+type Api struct {
+	port                      int
+	tlsCertFile               string
+	tlsKeyFile                string
+	startTimeout              time.Duration
+	timeout                   time.Duration
+	rootPath                  string
+	traceHeader               string
+	basicAuthUsername         string
+	basicAuthPassword         string
+	downloadFromCfg           downloadFromConfig
+	disableHealthCheckLogging bool
+
+	routes              []Route
+	externalMiddlewares []Middleware
+	healthChecks        []health.CheckerOption
+	readyFn             []func() error
+	fs                  *gotenberg.FileSystem
+	logger              *zap.Logger
+	srv                 *echo.Echo
+}
+
+type downloadFromConfig struct {
+	allowList *regexp2.Regexp
+	denyList  *regexp2.Regexp
+	maxRetry  int
+	disable   bool
+}
+
+// Router is a module interface which adds routes to the [Api].
+type Router interface {
+	Routes() ([]Route, error)
+}
+
+// Route represents a route from a [Router].
+type Route struct {
+	// Method is the HTTP method of the route (i.e., GET, POST, etc.).
+	// Required.
+	Method string
+
+	// Path is the sub path of the route. Must start with a slash.
+	// Required.
+	Path string
+
+	// IsMultipart tells if the route is "multipart/form-data".
+	// Optional.
+	IsMultipart bool
+
+	// DisableLogging disables the logging for this route.
+	// Optional.
+	DisableLogging bool
+
+	// Handler is the function which handles the request.
+	// Required.
+	Handler echo.HandlerFunc
+}
+
+// MiddlewareProvider is a module interface which adds middlewares to the [Api].
+type MiddlewareProvider interface {
+	Middlewares() ([]Middleware, error)
+}
+
+// MiddlewareStack is a type which helps to determine in which stack the
+// middlewares provided by the [MiddlewareProvider] modules should be located.
+type MiddlewareStack uint32
+
+const (
+	DefaultStack MiddlewareStack = iota
+	PreRouterStack
+	MultipartStack
+)
+
+// MiddlewarePriority is a type which helps to determine the execution order of
+// middlewares provided by the [MiddlewareProvider] modules in a stack.
+type MiddlewarePriority uint32
+
+const (
+	VeryLowPriority MiddlewarePriority = iota
+	LowPriority
+	MediumPriority
+	HighPriority
+	VeryHighPriority
+)
+
+// Middleware is a middleware which can be added to the [Api]'s middlewares
+// chain.
+//
+//	middleware := Middleware{
+//	  Handler: func() echo.MiddlewareFunc {
+//	    return func(next echo.HandlerFunc) echo.HandlerFunc {
+//	      return func(c echo.Context) error {
+//	        rootPath := c.Get("rootPath").(string)
+//	        healthURI := fmt.Sprintf("%shealth", rootPath)
+//
+//	        // Skip the middleware if health check URI.
+//	        if c.Request().RequestURI == healthURI {
+//	          // Call the next middleware in the chain.
+//	          return next(c)
+//	        }
+//
+//	        // Your middleware process.
+//	        // ...
+//
+//	        // Call the next middleware in the chain.
+//	        return next(c)
+//	      }
+//	    }
+//	  }(),
+//	}
+type Middleware struct {
+	// Stack tells in which stack the middleware should be located.
+	// Default to [DefaultStack].
+	// Optional.
+	Stack MiddlewareStack
+
+	// Priority tells if the middleware should be positioned high or not in
+	// its stack.
+	// Default to [VeryLowPriority].
+	// Optional.
+	Priority MiddlewarePriority
+
+	// Handler is the function of the middleware.
+	// Required.
+	Handler echo.MiddlewareFunc
+}
+
+// HealthChecker is a module interface which allows adding health checks to the
+// API.
+//
+// See https://github.com/alexliesenfeld/health for more details.
+type HealthChecker interface {
+	Checks() ([]health.CheckerOption, error)
+	Ready() error
+}
+
+// Descriptor returns an [Api]'s module descriptor.
+func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "api",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("api", flag.ExitOnError)
+			fs.Int("api-port", 3000, "Set the port on which the API should listen")
+			fs.String("api-port-from-env", "", "Set the environment variable with the port on which the API should listen - override the default port")
+			fs.String("api-tls-cert-file", "", "Path to the TLS/SSL certificate file - for HTTPS support")
+			fs.String("api-tls-key-file", "", "Path to the TLS/SSL key file - for HTTPS support")
+			fs.Duration("api-start-timeout", time.Duration(30)*time.Second, "Set the time limit for the API to start")
+			fs.Duration("api-timeout", time.Duration(30)*time.Second, "Set the time limit for requests")
+			fs.String("api-root-path", "/", "Set the root path of the API - for service discovery via URL paths")
+			fs.String("api-trace-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
+			fs.Bool("api-enable-basic-auth", false, "Enable basic authentication - will look for the GOTENBERG_API_BASIC_AUTH_USERNAME and GOTENBERG_API_BASIC_AUTH_PASSWORD environment variables")
+			fs.String("api-download-from-allow-list", "", "Set the allowed URLs for the download from feature using a regular expression")
+			fs.String("api-download-from-deny-list", "", "Set the denied URLs for the download from feature using a regular expression")
+			fs.Int("api-download-from-max-retry", 4, "Set the maximum number of retries for the download from feature")
+			fs.Bool("api-disable-download-from", false, "Disable the download from feature")
+			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(Api) },
+	}
+}
+
+// Provision sets the module properties.
+func (a *Api) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	a.port = flags.MustInt("api-port")
+	a.tlsCertFile = flags.MustString("api-tls-cert-file")
+	a.tlsKeyFile = flags.MustString("api-tls-key-file")
+	a.startTimeout = flags.MustDuration("api-start-timeout")
+	a.timeout = flags.MustDuration("api-timeout")
+	a.rootPath = flags.MustString("api-root-path")
+	a.traceHeader = flags.MustString("api-trace-header")
+	a.downloadFromCfg = downloadFromConfig{
+		allowList: flags.MustRegexp("api-download-from-allow-list"),
+		denyList:  flags.MustRegexp("api-download-from-deny-list"),
+		maxRetry:  flags.MustInt("api-download-from-max-retry"),
+		disable:   flags.MustBool("api-disable-download-from"),
+	}
+	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
+
+	// Port from env?
+	portEnvVar := flags.MustString("api-port-from-env")
+	if portEnvVar != "" {
+		port, err := gotenberg.IntEnv(portEnvVar)
+		if err != nil {
+			return fmt.Errorf("get API port from env: %w", err)
+		}
+		a.port = port
+	}
+
+	// Enable basic auth?
+	enableBasicAuth := flags.MustBool("api-enable-basic-auth")
+	if enableBasicAuth {
+		basicAuthUsername, err := gotenberg.StringEnv("GOTENBERG_API_BASIC_AUTH_USERNAME")
+		if err != nil {
+			return fmt.Errorf("get basic auth username from env: %w", err)
+		}
+		basicAuthPassword, err := gotenberg.StringEnv("GOTENBERG_API_BASIC_AUTH_PASSWORD")
+		if err != nil {
+			return fmt.Errorf("get basic auth password from env: %w", err)
+		}
+		a.basicAuthUsername = basicAuthUsername
+		a.basicAuthPassword = basicAuthPassword
+	}
+
+	// Get routes from modules.
+	mods, err := ctx.Modules(new(Router))
+	if err != nil {
+		return fmt.Errorf("get routers: %w", err)
+	}
+
+	routers := make([]Router, len(mods))
+	for i, router := range mods {
+		routers[i] = router.(Router)
+	}
+
+	for _, router := range routers {
+		routes, err := router.Routes()
+		if err != nil {
+			return fmt.Errorf("get routes: %w", err)
+		}
+
+		a.routes = append(a.routes, routes...)
+	}
+
+	// Get middlewares from modules.
+	mods, err = ctx.Modules(new(MiddlewareProvider))
+	if err != nil {
+		return fmt.Errorf("get middleware providers: %w", err)
+	}
+
+	middlewareProviders := make([]MiddlewareProvider, len(mods))
+	for i, middlewareProvider := range mods {
+		middlewareProviders[i] = middlewareProvider.(MiddlewareProvider)
+	}
+
+	for _, middlewareProvider := range middlewareProviders {
+		middlewares, err := middlewareProvider.Middlewares()
+		if err != nil {
+			return fmt.Errorf("get middlewares: %w", err)
+		}
+
+		a.externalMiddlewares = append(a.externalMiddlewares, middlewares...)
+	}
+
+	// Sort middlewares by priority.
+	sort.Slice(a.externalMiddlewares, func(i, j int) bool {
+		return a.externalMiddlewares[i].Priority > a.externalMiddlewares[j].Priority
+	})
+
+	// Get health checks from modules.
+	mods, err = ctx.Modules(new(HealthChecker))
+	if err != nil {
+		return fmt.Errorf("get health checkers: %w", err)
+	}
+
+	healthCheckers := make([]HealthChecker, len(mods))
+	for i, healthChecker := range mods {
+		healthCheckers[i] = healthChecker.(HealthChecker)
+	}
+
+	for _, healthChecker := range healthCheckers {
+		checks, err := healthChecker.Checks()
+		if err != nil {
+			return fmt.Errorf("get health checks: %w", err)
+		}
+
+		a.healthChecks = append(a.healthChecks, checks...)
+		a.readyFn = append(a.readyFn, healthChecker.Ready)
+	}
+
+	// Logger.
+	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
+	if err != nil {
+		return fmt.Errorf("get logger provider: %w", err)
+	}
+
+	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(a)
+	if err != nil {
+		return fmt.Errorf("get logger: %w", err)
+	}
+
+	a.logger = logger
+
+	// File system.
+	a.fs = gotenberg.NewFileSystem()
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (a *Api) Validate() error {
+	var err error
+
+	if a.port < 1 || a.port > 65535 {
+		err = multierr.Append(err,
+			errors.New("port must be more than 1 and less than 65535"),
+		)
+	}
+
+	if (a.tlsCertFile != "" && a.tlsKeyFile == "") || (a.tlsCertFile == "" && a.tlsKeyFile != "") {
+		err = multierr.Append(err,
+			errors.New("both TLS certificate and key files must be set"),
+		)
+	}
+
+	if !strings.HasPrefix(a.rootPath, "/") {
+		err = multierr.Append(err,
+			errors.New("root path must start with /"),
+		)
+	}
+
+	if !strings.HasSuffix(a.rootPath, "/") {
+		err = multierr.Append(err,
+			errors.New("root path must end with /"),
+		)
+	}
+
+	if len(strings.TrimSpace(a.traceHeader)) == 0 {
+		err = multierr.Append(err,
+			errors.New("trace header must not be empty"),
+		)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	routesMap := make(map[string]string, len(a.routes)+2)
+	routesMap["/health"] = "/health"
+	routesMap["/version"] = "/version"
+
+	for _, route := range a.routes {
+		if route.Path == "" {
+			return errors.New("route with empty path cannot be registered")
+		}
+
+		if !strings.HasPrefix(route.Path, "/") {
+			return fmt.Errorf("route '%s' does not start with /", route.Path)
+		}
+
+		if route.IsMultipart && !strings.HasPrefix(route.Path, "/forms") {
+			return fmt.Errorf("multipart/form-data route '%s' does not start with /forms", route.Path)
+		}
+
+		if route.Method == "" {
+			return fmt.Errorf("route '%s' has an empty method", route.Path)
+		}
+
+		if route.Handler == nil {
+			return fmt.Errorf("route '%s' has a nil handler", route.Path)
+		}
+
+		if _, ok := routesMap[route.Path]; ok {
+			return fmt.Errorf("route '%s' is already registered", route.Path)
+		}
+
+		routesMap[route.Path] = route.Path
+	}
+
+	for _, middleware := range a.externalMiddlewares {
+		if middleware.Handler == nil {
+			return errors.New("a middleware has a nil handler")
+		}
+	}
+
+	return nil
+}
+
+// Start starts the HTTP server.
+func (a *Api) Start() error {
+	a.srv = echo.New()
+	a.srv.HideBanner = true
+	a.srv.HidePort = true
+	a.srv.Server.ReadTimeout = a.timeout
+	a.srv.Server.IdleTimeout = a.timeout
+	// See https://github.com/gotenberg/gotenberg/issues/396.
+	a.srv.Server.WriteTimeout = a.timeout + a.timeout
+	a.srv.HTTPErrorHandler = httpErrorHandler()
+
+	// Let's prepare the modules' routes.
+	var disableLoggingForPaths []string
+	for i, route := range a.routes {
+		a.routes[i].Path = strings.TrimPrefix(route.Path, "/")
+
+		if route.DisableLogging {
+			disableLoggingForPaths = append(disableLoggingForPaths, strings.TrimPrefix(route.Path, "/"))
+		}
+	}
+
+	// Check if the user wish to add logging entries related to the health
+	// check route.
+	if a.disableHealthCheckLogging {
+		disableLoggingForPaths = append(disableLoggingForPaths, "health")
+	}
+
+	// Add the API middlewares.
+	a.srv.Pre(
+		latencyMiddleware(),
+		rootPathMiddleware(a.rootPath),
+		traceMiddleware(a.traceHeader),
+		loggerMiddleware(a.logger, disableLoggingForPaths),
+	)
+
+	// Add the modules' middlewares in their respective stacks.
+	var externalMultipartMiddlewares []Middleware
+	for _, externalMiddleware := range a.externalMiddlewares {
+		switch externalMiddleware.Stack {
+		case PreRouterStack:
+			a.srv.Pre(externalMiddleware.Handler)
+		case MultipartStack:
+			externalMultipartMiddlewares = append(externalMultipartMiddlewares, externalMiddleware)
+		case DefaultStack:
+			a.srv.Use(externalMiddleware.Handler)
+		}
+	}
+
+	hardTimeout := a.timeout + (time.Duration(5) * time.Second)
+
+	// Add the modules' routes and their specific middlewares.
+	for _, route := range a.routes {
+		var middlewares []echo.MiddlewareFunc
+
+		// Basic auth?
+		if a.basicAuthUsername != "" {
+			middlewares = append(middlewares, basicAuthMiddleware(a.basicAuthUsername, a.basicAuthPassword))
+		}
+
+		if route.IsMultipart {
+			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout, a.downloadFromCfg))
+
+			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
+				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
+			}
+		}
+
+		middlewares = append(middlewares, hardTimeoutMiddleware(hardTimeout))
+
+		a.srv.Add(
+			route.Method,
+			fmt.Sprintf("%s%s", a.rootPath, route.Path),
+			route.Handler,
+			middlewares...,
+		)
+	}
+
+	// Let's not forget the health check routes...
+	checks := append(a.healthChecks, health.WithTimeout(a.timeout))
+	checker := health.NewChecker(checks...)
+	healthCheckHandler := health.NewHandler(checker)
+
+	a.srv.GET(
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
+		func() echo.HandlerFunc {
+			return echo.WrapHandler(healthCheckHandler)
+		}(),
+		hardTimeoutMiddleware(hardTimeout),
+	)
+	a.srv.HEAD(
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
+		func() echo.HandlerFunc {
+			return echo.WrapHandler(healthCheckHandler)
+		}(),
+		hardTimeoutMiddleware(hardTimeout),
+	)
+
+	// ...and the version route.
+	a.srv.GET(
+		fmt.Sprintf("%s%s", a.rootPath, "version"),
+		func(c echo.Context) error {
+			return c.String(http.StatusOK, gotenberg.Version)
+		},
+	)
+
+	// Wait for all modules to be ready.
+	ctx, cancel := context.WithTimeout(context.Background(), a.startTimeout)
+	defer cancel()
+
+	eg, _ := errgroup.WithContext(ctx)
+	for _, f := range a.readyFn {
+		eg.Go(f)
+	}
+
+	err := eg.Wait()
+	if err != nil {
+		return fmt.Errorf("waiting for modules readiness: %w", err)
+	}
+
+	// As the following code is blocking, run it in a goroutine.
+	go func() {
+		var err error
+		if a.tlsCertFile != "" && a.tlsKeyFile != "" {
+			// Start an HTTPS server (supports HTTP/2).
+			err = a.srv.StartTLS(fmt.Sprintf(":%d", a.port), a.tlsCertFile, a.tlsKeyFile)
+		} else {
+			// Start an HTTP/2 Cleartext (non-HTTPS) server.
+			server := &http2.Server{}
+			err = a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
+		}
+		if !errors.Is(err, http.ErrServerClosed) {
+			a.logger.Fatal(err.Error())
+		}
+	}()
+
+	return nil
+}
+
+// StartupMessage returns a custom startup message.
+func (a *Api) StartupMessage() string {
+	return fmt.Sprintf("server listening on port %d", a.port)
+}
+
+// Stop stops the HTTP server.
+func (a *Api) Stop(ctx context.Context) error {
+	return a.srv.Shutdown(ctx)
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*Api)(nil)
+	_ gotenberg.Provisioner = (*Api)(nil)
+	_ gotenberg.Validator   = (*Api)(nil)
+	_ gotenberg.App         = (*Api)(nil)
+)

pkg/modules/api/api_test.go

@@ -0,0 +1,955 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/alexliesenfeld/health"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestApi_Descriptor(t *testing.T) {
+	descriptor := new(Api).Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Api))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestApi_Provision(t *testing.T) {
+	for _, tc := range []struct {
+		scenario          string
+		ctx               *gotenberg.Context
+		setEnv            func()
+		expectPort        int
+		expectMiddlewares []Middleware
+		expectError       bool
+	}{
+		{
+			scenario: "port from env: non-existing environment variable",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-port-from-env=FOO"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "basic auth: non-existing GOTENBERG_API_BASIC_AUTH_USERNAME environment variable",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-enable-basic-auth=true"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "basic auth: non-existing GOTENBERG_API_BASIC_AUTH_PASSWORD environment variable",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-enable-basic-auth=true"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func() {
+				err := os.Setenv("GOTENBERG_API_BASIC_AUTH_USERNAME", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectError: true,
+		},
+		{
+			scenario: "port from env: invalid environment variable value",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-port-from-env=PORT"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func() {
+				err := os.Setenv("PORT", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectError: true,
+		},
+		{
+			scenario: "no valid routers",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					RouterMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.ValidateMock = func() error {
+					return errors.New("foo")
+				}
+				mod.RoutesMock = func() ([]Route, error) {
+					return nil, nil
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "cannot retrieve routes from router",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					RouterMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.RoutesMock = func() ([]Route, error) {
+					return nil, errors.New("foo")
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no valid middleware providers",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					MiddlewareProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.ValidateMock = func() error {
+					return errors.New("foo")
+				}
+				mod.MiddlewaresMock = func() ([]Middleware, error) {
+					return nil, nil
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "cannot retrieve middlewares from middleware provider",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					MiddlewareProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.MiddlewaresMock = func() ([]Middleware, error) {
+					return nil, errors.New("foo")
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no valid health checkers",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.ValidatorMock
+					HealthCheckerMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.ValidateMock = func() error {
+					return errors.New("foo")
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "cannot retrieve health checks from health checker",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					HealthCheckerMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.ChecksMock = func() ([]health.CheckerOption, error) {
+					return nil, errors.New("foo")
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no logger provider",
+			ctx: func() *gotenberg.Context {
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "no logger from logger provider",
+			ctx: func() *gotenberg.Context {
+				mod := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.LoggerMock = func(mod gotenberg.Module) (*zap.Logger, error) {
+					return nil, errors.New("foo")
+				}
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Api).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			ctx: func() *gotenberg.Context {
+				mod1 := &struct {
+					gotenberg.ModuleMock
+					RouterMock
+				}{}
+				mod1.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
+				}
+				mod1.RoutesMock = func() ([]Route, error) {
+					return []Route{{}}, nil
+				}
+
+				mod2 := &struct {
+					gotenberg.ModuleMock
+					MiddlewareProviderMock
+				}{}
+				mod2.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "bar", New: func() gotenberg.Module { return mod2 }}
+				}
+				mod2.MiddlewaresMock = func() ([]Middleware, error) {
+					return []Middleware{
+						{
+							Priority: VeryLowPriority,
+						},
+						{
+							Priority: LowPriority,
+						},
+						{
+							Priority: MediumPriority,
+						},
+						{
+							Priority: HighPriority,
+						},
+						{
+							Priority: VeryHighPriority,
+						},
+					}, nil
+				}
+
+				mod3 := &struct {
+					gotenberg.ModuleMock
+					HealthCheckerMock
+				}{}
+				mod3.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "baz", New: func() gotenberg.Module { return mod3 }}
+				}
+				mod3.ChecksMock = func() ([]health.CheckerOption, error) {
+					return []health.CheckerOption{health.WithDisabledAutostart()}, nil
+				}
+				mod3.ReadyMock = func() error {
+					return nil
+				}
+
+				mod4 := &struct {
+					gotenberg.ModuleMock
+					gotenberg.LoggerProviderMock
+				}{}
+				mod4.DescriptorMock = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "qux", New: func() gotenberg.Module { return mod4 }}
+				}
+				mod4.LoggerMock = func(_ gotenberg.Module) (*zap.Logger, error) {
+					return zap.NewNop(), nil
+				}
+
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-port-from-env=PORT", "--api-enable-basic-auth=true"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod1.Descriptor(),
+						mod2.Descriptor(),
+						mod3.Descriptor(),
+						mod4.Descriptor(),
+					},
+				)
+			}(),
+			setEnv: func() {
+				err := os.Setenv("PORT", "1337")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = os.Setenv("GOTENBERG_API_BASIC_AUTH_USERNAME", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = os.Setenv("GOTENBERG_API_BASIC_AUTH_PASSWORD", "bar")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectPort: 1337,
+			expectMiddlewares: []Middleware{
+				{
+					Priority: VeryHighPriority,
+				},
+				{
+					Priority: HighPriority,
+				},
+				{
+					Priority: MediumPriority,
+				},
+				{
+					Priority: LowPriority,
+				},
+				{
+					Priority: VeryLowPriority,
+				},
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.setEnv != nil {
+				tc.setEnv()
+			}
+
+			mod := new(Api)
+			err := mod.Provision(tc.ctx)
+
+			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.expectPort != 0 && mod.port != tc.expectPort {
+				t.Errorf("expected port %d but got %d", tc.expectPort, mod.port)
+			}
+
+			if !reflect.DeepEqual(mod.externalMiddlewares, tc.expectMiddlewares) {
+				t.Errorf("expected %+v, but got: %+v", tc.expectMiddlewares, mod.externalMiddlewares)
+			}
+		})
+	}
+}
+
+func TestApi_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		port        int
+		tlsCertFile string
+		tlsKeyFile  string
+		rootPath    string
+		traceHeader string
+		routes      []Route
+		middlewares []Middleware
+		expectError bool
+	}{
+		{
+			scenario:    "invalid port (< 1)",
+			port:        0,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid port (> 65535)",
+			port:        65536,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid TLS files: only cert file provided",
+			port:        10,
+			tlsCertFile: "cert.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid TLS files: only key file provided",
+			port:        10,
+			tlsKeyFile:  "key.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid root path: missing / prefix",
+			port:        10,
+			rootPath:    "foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid root path: missing / suffix",
+			port:        10,
+			rootPath:    "/foo",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid trace header",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid route: empty path",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Path: "",
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid route: missing / prefix in path",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Path: "foo",
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid multipart route: no /forms prefix in path",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Path:        "/foo",
+					IsMultipart: true,
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid route: no method",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Path:   "/foo",
+					Method: "",
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid route: nil handler",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodPost,
+					Path:    "/foo",
+					Handler: nil,
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid route: path already existing",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodPost,
+					Path:    "/foo",
+					Handler: func(_ echo.Context) error { return nil },
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/foo",
+					Handler: func(_ echo.Context) error { return nil },
+				},
+			},
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid middleware: nil handler",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: []Middleware{
+				{
+					Priority: HighPriority,
+					Handler:  nil,
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario:    "success",
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodGet,
+					Path:    "/foo",
+					Handler: func(_ echo.Context) error { return nil },
+				},
+				{
+					Method:      http.MethodGet,
+					Path:        "/forms/foo",
+					Handler:     func(_ echo.Context) error { return nil },
+					IsMultipart: true,
+				},
+			},
+			middlewares: []Middleware{
+				{
+					Priority: HighPriority,
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+			},
+		},
+		{
+			scenario:    "success with TLS",
+			port:        10,
+			tlsCertFile: "cert.pem",
+			tlsKeyFile:  "key.pem",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodGet,
+					Path:    "/foo",
+					Handler: func(_ echo.Context) error { return nil },
+				},
+				{
+					Method:      http.MethodGet,
+					Path:        "/forms/foo",
+					Handler:     func(_ echo.Context) error { return nil },
+					IsMultipart: true,
+				},
+			},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := Api{
+				port:                tc.port,
+				tlsCertFile:         tc.tlsCertFile,
+				tlsKeyFile:          tc.tlsKeyFile,
+				rootPath:            tc.rootPath,
+				traceHeader:         tc.traceHeader,
+				routes:              tc.routes,
+				externalMiddlewares: tc.middlewares,
+			}
+
+			err := mod.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 TestApi_Start(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		readyFn     []func() error
+		tlsCertFile string
+		tlsKeyFile  string
+		expectError bool
+	}{
+		{
+			scenario: "at least one module not ready",
+			readyFn: []func() error{
+				func() error { return nil },
+				func() error { return errors.New("not ready") },
+			},
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			readyFn: []func() error{
+				func() error { return nil },
+				func() error { return nil },
+			},
+			expectError: false,
+		},
+		{
+			scenario: "success with TLS",
+			readyFn: []func() error{
+				func() error { return nil },
+				func() error { return nil },
+			},
+			tlsCertFile: "/tests/test/testdata/api/cert.pem",
+			tlsKeyFile:  "/tests/test/testdata/api/key.pem",
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := new(Api)
+			mod.port = 3000
+			mod.tlsCertFile = tc.tlsCertFile
+			mod.tlsKeyFile = tc.tlsKeyFile
+			mod.startTimeout = time.Duration(30) * time.Second
+			mod.rootPath = "/"
+			mod.basicAuthUsername = "foo"
+			mod.basicAuthPassword = "bar"
+			mod.disableHealthCheckLogging = true
+			mod.routes = []Route{
+				{
+					Method:         http.MethodPost,
+					Path:           "/forms/foo",
+					IsMultipart:    true,
+					DisableLogging: true,
+					Handler: func(c echo.Context) error {
+						ctx := c.Get("context").(*Context)
+						ctx.outputPaths = []string{
+							"/tests/test/testdata/api/sample1.txt",
+						}
+
+						return nil
+					},
+				},
+				{
+					Method:      http.MethodPost,
+					Path:        "/forms/bar",
+					IsMultipart: true,
+					Handler:     func(_ echo.Context) error { return errors.New("foo") },
+				},
+			}
+			mod.externalMiddlewares = []Middleware{
+				{
+					Stack: PreRouterStack,
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+				{
+					Stack: MultipartStack,
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+				{
+					Stack: DefaultStack,
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+				{
+					Handler: func() echo.MiddlewareFunc {
+						return func(next echo.HandlerFunc) echo.HandlerFunc {
+							return func(c echo.Context) error {
+								return next(c)
+							}
+						}
+					}(),
+				},
+			}
+			mod.readyFn = tc.readyFn
+			mod.fs = gotenberg.NewFileSystem()
+			mod.logger = zap.NewNop()
+
+			err := mod.Start()
+			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.expectError {
+				return
+			}
+
+			// health requests.
+			recorder := httptest.NewRecorder()
+
+			healthGetRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthGetRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			healthHeadRequest := httptest.NewRequest(http.MethodHead, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthHeadRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			// version request.
+			versionRequest := httptest.NewRequest(http.MethodGet, "/version", nil)
+			mod.srv.ServeHTTP(recorder, versionRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			// "multipart/form-data" request.
+			multipartRequest := func(url string) *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+
+				err := writer.WriteField("foo", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				part, err := writer.CreateFormFile("foo.txt", "foo.txt")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				_, err = part.Write([]byte("foo"))
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				req := httptest.NewRequest(http.MethodPost, url, body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				req.SetBasicAuth(mod.basicAuthUsername, mod.basicAuthPassword)
+
+				return req
+			}
+
+			recorder = httptest.NewRecorder()
+			mod.srv.ServeHTTP(recorder, multipartRequest("/forms/foo"))
+
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			recorder = httptest.NewRecorder()
+			mod.srv.ServeHTTP(recorder, multipartRequest("/forms/bar"))
+
+			if recorder.Code != http.StatusInternalServerError {
+				t.Errorf("expected %d status code but got %d", http.StatusInternalServerError, recorder.Code)
+			}
+
+			err = mod.srv.Shutdown(context.TODO())
+			if err != nil {
+				t.Errorf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestApi_StartupMessage(t *testing.T) {
+	mod := Api{
+		port: 3000,
+	}
+
+	actual := mod.StartupMessage()
+	expect := "server listening on port 3000"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestApi_Stop(t *testing.T) {
+	mod := &Api{
+		port: 3000,
+		routes: []Route{
+			{
+				Method:  http.MethodGet,
+				Path:    "/foo",
+				Handler: func(_ echo.Context) error { return nil },
+			},
+		},
+		logger: zap.NewNop(),
+	}
+
+	err := mod.Start()
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	err = mod.Stop(context.TODO())
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}

pkg/modules/api/context.go

@@ -0,0 +1,444 @@
+package api
+
+import (
+	"compress/flate"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/labstack/echo/v4"
+	"github.com/mholt/archiver/v3"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+var (
+	// ErrContextAlreadyClosed happens when the context has been canceled.
+	ErrContextAlreadyClosed = errors.New("context already closed")
+
+	// ErrOutOfBoundsOutputPath happens when an output path is not within
+	// context's working directory. It enforces having all the files in the
+	// same directory.
+	ErrOutOfBoundsOutputPath = errors.New("output path is not within context's working directory")
+)
+
+// Context is the request context for a "multipart/form-data" requests.
+type Context struct {
+	dirPath     string
+	values      map[string][]string
+	files       map[string]string
+	outputPaths []string
+	cancelled   bool
+
+	logger     *zap.Logger
+	echoCtx    echo.Context
+	pathRename gotenberg.PathRename
+	context.Context
+}
+
+type downloadFrom struct {
+	// Url is the URL to download a file from.
+	Url string `json:"url"`
+
+	// ExtraHttpHeaders are the HTTP headers to send alongside.
+	ExtraHttpHeaders map[string]string `json:"extraHttpHeaders"`
+}
+
+type osPathRename struct{}
+
+func (o *osPathRename) Rename(oldpath, newpath string) error {
+	return os.Rename(oldpath, newpath)
+}
+
+// newContext returns a [Context] by parsing a "multipart/form-data" request.
+func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration, downloadFromCfg downloadFromConfig, traceHeader, trace string) (*Context, context.CancelFunc, error) {
+	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)
+
+	ctx := &Context{
+		outputPaths: make([]string, 0),
+		cancelled:   false,
+		logger:      logger,
+		echoCtx:     echoCtx,
+		pathRename:  new(osPathRename),
+		Context:     processCtx,
+	}
+
+	// A custom cancel function which removes the context's working directory
+	// when called.
+	cancel := func() context.CancelFunc {
+		return func() {
+			if ctx.cancelled {
+				return
+			}
+
+			processCancel()
+
+			if ctx.dirPath == "" {
+				return
+			}
+
+			err := os.RemoveAll(ctx.dirPath)
+			if err != nil {
+				ctx.logger.Error(fmt.Sprintf("remove context's working directory: %s", err))
+
+				return
+			}
+
+			ctx.logger.Debug(fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
+			ctx.cancelled = true
+		}
+	}()
+
+	form, err := echoCtx.MultipartForm()
+	if err != nil {
+		if errors.Is(err, http.ErrNotMultipart) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHttpError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: want 'multipart/form-data'"),
+			)
+		}
+
+		if errors.Is(err, http.ErrMissingBoundary) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHttpError(http.StatusUnsupportedMediaType, "Invalid 'Content-Type' header value: no boundary"),
+			)
+		}
+
+		if strings.Contains(err.Error(), io.EOF.Error()) {
+			return nil, cancel, WrapError(
+				fmt.Errorf("get multipart form: %w", err),
+				NewSentinelHttpError(http.StatusBadRequest, "Malformed body: it does not match the 'Content-Type' header boundaries"),
+			)
+		}
+
+		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
+	}
+
+	dirPath, err := fs.MkdirAll()
+	if err != nil {
+		return nil, cancel, fmt.Errorf("create working directory: %w", err)
+	}
+
+	ctx.dirPath = dirPath
+	ctx.values = form.Value
+	ctx.files = make(map[string]string)
+
+	// First, try to download files listed in the "downloadFrom" form field, if
+	// any.
+	raw, ok := ctx.values["downloadFrom"]
+	if !downloadFromCfg.disable && ok {
+		var dls []downloadFrom
+		err = json.Unmarshal([]byte(raw[0]), &dls)
+		if err != nil {
+			return nil, cancel, WrapError(
+				fmt.Errorf("unmarshal json: %w", err),
+				NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field value: %s", err)),
+			)
+		}
+
+		eg, _ := errgroup.WithContext(ctx)
+		for i, dl := range dls {
+			eg.Go(func() error {
+				deadline, ok := ctx.Deadline()
+				if !ok {
+					// Should not happen, as context is created with a timeout.
+					return errors.New("context has no deadline")
+				}
+
+				if strings.TrimSpace(dl.Url) == "" {
+					return WrapError(
+						errors.New("empty download from URL"),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field entry %d: URL must be set", i)),
+					)
+				}
+
+				err := gotenberg.FilterDeadline(downloadFromCfg.allowList, downloadFromCfg.denyList, dl.Url, deadline)
+				if err != nil {
+					return fmt.Errorf("filter URL: %w", err)
+				}
+
+				logger.Debug(fmt.Sprintf("download file from '%s'", dl.Url))
+
+				req, err := retryablehttp.NewRequest(http.MethodGet, dl.Url, nil)
+				if err != nil {
+					return fmt.Errorf("create request to '%s': %w", dl.Url, err)
+				}
+
+				req.Header.Set("User-Agent", "Gotenberg")
+				for key, value := range dl.ExtraHttpHeaders {
+					req.Header.Set(key, value)
+				}
+				req.Header.Set(traceHeader, trace)
+
+				client := &retryablehttp.Client{
+					HTTPClient: &http.Client{
+						Timeout: time.Until(deadline),
+					},
+					RetryMax:     downloadFromCfg.maxRetry,
+					RetryWaitMin: time.Duration(1) * time.Second,
+					RetryWaitMax: time.Until(deadline),
+					Logger:       gotenberg.NewLeveledLogger(logger),
+					CheckRetry:   retryablehttp.DefaultRetryPolicy,
+					Backoff:      retryablehttp.DefaultBackoff,
+				}
+
+				resp, err := client.Do(req)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': %w", dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': %s", dl.Url, err)),
+					)
+				}
+				defer func() {
+					err := resp.Body.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close response body from '%s': %s", dl.Url, err))
+					}
+				}()
+
+				if resp.StatusCode != http.StatusOK {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': got status: '%s'", dl.Url, resp.Status),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': got status: '%s'", dl.Url, resp.Status)),
+					)
+				}
+
+				contentDisposition := resp.Header.Get("Content-Disposition")
+				if contentDisposition == "" {
+					return WrapError(
+						fmt.Errorf("no 'Content-Disposition' header from '%s'", dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("No 'Content-Disposition' header from '%s'", dl.Url)),
+					)
+				}
+
+				// FIXME: the implementation of this method might not be
+				//  complete, as it fails to parse an empty mediatype.
+				//  See: https://github.com/golang/go/issues/69551.
+				_, params, err := mime.ParseMediaType(contentDisposition)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("parse 'Content-Disposition' header '%s' from '%s': %w", contentDisposition, dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': %s", contentDisposition, dl.Url, err)),
+					)
+				}
+
+				filename, ok := params["filename"]
+				if !ok {
+					return WrapError(
+						fmt.Errorf("get filename from 'Content-Disposition' header '%s' from '%s'", contentDisposition, dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': no filename", contentDisposition, dl.Url)),
+					)
+				}
+
+				// Avoid directory traversal and make sure filename characters are
+				// normalized.
+				// See: https://github.com/gotenberg/gotenberg/issues/662.
+				filename = norm.NFC.String(filepath.Base(filename))
+				path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+
+				out, err := os.Create(path)
+				if err != nil {
+					return fmt.Errorf("create local file: %w", err)
+				}
+				defer func() {
+					err := out.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close local file: %s", err))
+					}
+				}()
+
+				_, err = io.Copy(out, resp.Body)
+				if err != nil {
+					return fmt.Errorf("copy downloaded file from '%s' to local file: %v", dl.Url, err)
+				}
+
+				ctx.files[filename] = path
+
+				return nil
+			})
+		}
+
+		err = eg.Wait()
+		if err != nil {
+			return ctx, cancel, err
+		}
+	}
+
+	copyToDisk := func(fh *multipart.FileHeader) error {
+		in, err := fh.Open()
+		if err != nil {
+			return fmt.Errorf("open multipart file: %w", err)
+		}
+
+		defer func() {
+			err := in.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close file header: %s", err))
+			}
+		}()
+
+		// Avoid directory traversal and make sure filename characters are
+		// normalized.
+		// See: https://github.com/gotenberg/gotenberg/issues/662.
+		filename := norm.NFC.String(filepath.Base(fh.Filename))
+		path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+
+		out, err := os.Create(path)
+		if err != nil {
+			return fmt.Errorf("create local file: %w", err)
+		}
+		defer func() {
+			err := out.Close()
+			if err != nil {
+				logger.Error(fmt.Sprintf("close local file: %s", err))
+			}
+		}()
+
+		_, err = io.Copy(out, in)
+		if err != nil {
+			return fmt.Errorf("copy multipart file to local file: %w", err)
+		}
+
+		ctx.files[filename] = path
+
+		return nil
+	}
+
+	// Then, copy the form files, if any.
+	for _, files := range form.File {
+		for _, fh := range files {
+			err = copyToDisk(fh)
+			if err != nil {
+				return ctx, cancel, fmt.Errorf("copy to disk: %w", err)
+			}
+		}
+	}
+
+	ctx.Log().Debug(fmt.Sprintf("form fields: %+v", ctx.values))
+	ctx.Log().Debug(fmt.Sprintf("form files: %+v", ctx.files))
+
+	return ctx, cancel, err
+}
+
+// Request returns the [http.Request].
+func (ctx *Context) Request() *http.Request {
+	return ctx.echoCtx.Request()
+}
+
+// FormData return a [FormData].
+func (ctx *Context) FormData() *FormData {
+	return &FormData{
+		values: ctx.values,
+		files:  ctx.files,
+		errors: nil,
+	}
+}
+
+// GeneratePath generates a path within the context's working directory.
+// It generates a new UUID-based filename. It does not create a file.
+func (ctx *Context) GeneratePath(extension string) string {
+	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New().String(), extension)
+}
+
+// Rename is just a wrapper around [os.Rename], as we need to mock this
+// behavior in our tests.
+func (ctx *Context) Rename(oldpath, newpath string) error {
+	err := ctx.pathRename.Rename(oldpath, newpath)
+	if err != nil {
+		return fmt.Errorf("rename path: %w", err)
+	}
+	return nil
+}
+
+// AddOutputPaths adds the given paths. Those paths will be used later to build
+// the output file.
+func (ctx *Context) AddOutputPaths(paths ...string) error {
+	if ctx.cancelled {
+		return ErrContextAlreadyClosed
+	}
+
+	for _, path := range paths {
+		if !strings.HasPrefix(path, ctx.dirPath) {
+			return ErrOutOfBoundsOutputPath
+		}
+
+		ctx.outputPaths = append(ctx.outputPaths, path)
+	}
+
+	return nil
+}
+
+// Log returns the context [zap.Logger].
+func (ctx *Context) Log() *zap.Logger {
+	return ctx.logger
+}
+
+// BuildOutputFile builds the output file according to the output paths
+// registered in the context. If many output paths, an archive is created.
+func (ctx *Context) BuildOutputFile() (string, error) {
+	if ctx.cancelled {
+		return "", ErrContextAlreadyClosed
+	}
+
+	if len(ctx.outputPaths) == 0 {
+		return "", errors.New("no output path")
+	}
+
+	if len(ctx.outputPaths) == 1 {
+		ctx.logger.Debug(fmt.Sprintf("only one output file '%s', skip archive creation", ctx.outputPaths[0]))
+
+		return ctx.outputPaths[0], nil
+	}
+
+	z := archiver.Zip{
+		CompressionLevel:       flate.DefaultCompression,
+		MkdirAll:               true,
+		SelectiveCompression:   true,
+		ContinueOnError:        false,
+		OverwriteExisting:      false,
+		ImplicitTopLevelFolder: false,
+	}
+
+	archivePath := ctx.GeneratePath(".zip")
+
+	err := z.Archive(ctx.outputPaths, archivePath)
+	if err != nil {
+		return "", fmt.Errorf("archive output files: %w", err)
+	}
+
+	ctx.logger.Debug(fmt.Sprintf("archive '%s' created", archivePath))
+
+	return archivePath, nil
+}
+
+// OutputFilename returns the filename based on the given output path or the
+// "Gotenberg-Output-Filename" header's value.
+func (ctx *Context) OutputFilename(outputPath string) string {
+	filename := ctx.echoCtx.Request().Header.Get("Gotenberg-Output-Filename")
+
+	if filename == "" {
+		return filepath.Base(outputPath)
+	}
+
+	return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
+}
+
+// Interface guard.
+var (
+	_ gotenberg.PathRename = (*osPathRename)(nil)
+)

pkg/modules/api/context_test.go

@@ -0,0 +1,765 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/dlclark/regexp2"
+	"github.com/google/uuid"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestOsPathRename_Rename(t *testing.T) {
+	dirPath, err := gotenberg.NewFileSystem().MkdirAll()
+	if err != nil {
+		t.Fatalf("create working directory: %v", err)
+	}
+
+	path := "/tests/test/testdata/api/sample1.txt"
+	copyPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	in, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open file: %v", err)
+	}
+
+	defer func() {
+		err := in.Close()
+		if err != nil {
+			t.Fatalf("close file: %v", err)
+		}
+	}()
+
+	out, err := os.Create(copyPath)
+	if err != nil {
+		t.Fatalf("create new file: %v", err)
+	}
+
+	defer func() {
+		err := out.Close()
+		if err != nil {
+			t.Fatalf("close new file: %v", err)
+		}
+	}()
+
+	_, err = io.Copy(out, in)
+	if err != nil {
+		t.Fatalf("copy file to new file: %v", err)
+	}
+
+	rename := new(osPathRename)
+	newPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	err = rename.Rename(copyPath, newPath)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("remove working directory: %v", err)
+	}
+}
+
+func TestNewContext(t *testing.T) {
+	defaultAllowList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDenyList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDownloadFromCfg := downloadFromConfig{
+		allowList: defaultAllowList,
+		denyList:  defaultDenyList,
+		maxRetry:  1,
+		disable:   false,
+	}
+
+	for _, tc := range []struct {
+		scenario         string
+		request          *http.Request
+		downloadFromCfg  downloadFromConfig
+		downloadFromSrv  *echo.Echo
+		expectContext    *Context
+		expectError      bool
+		expectHttpError  bool
+		expectHttpStatus int
+	}{
+		{
+			scenario:         "http.ErrNotMultipart",
+			request:          httptest.NewRequest(http.MethodPost, "/", nil),
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusUnsupportedMediaType,
+		},
+		{
+			scenario: "http.ErrMissingBoundary",
+			request: func() *http.Request {
+				req := httptest.NewRequest(http.MethodPost, "/", nil)
+				req.Header.Set(echo.HeaderContentType, echo.MIMEMultipartForm)
+				return req
+			}(),
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusUnsupportedMediaType,
+		},
+		{
+			scenario: "malformed body",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("foo", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", nil)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: cannot unmarshal",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: filtered URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"https://foo.bar"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg: func() downloadFromConfig {
+				denyList, err := regexp2.Compile("https://foo.bar", 0)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return downloadFromConfig{allowList: defaultAllowList, denyList: denyList, maxRetry: 1, disable: false}
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "invalid downloadFrom form field: unreachable URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: invalid status code",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusNotFound, http.StatusText(http.StatusNotFound))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: malformed 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, ";;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no filename parameter in 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, "inline;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "success",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("foo", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				part, err := writer.CreateFormFile("foo.txt", "foo.txt")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				_, err = part.Write([]byte("foo"))
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				err = writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					if c.Request().Header.Get("User-Agent") != "Gotenberg" {
+						t.Fatalf("expected 'Gotenberg' from header 'User-Agent', but got '%s'", c.Request().Header.Get("User-Agent"))
+					}
+					if c.Request().Header.Get("X-Foo") != "Bar" {
+						t.Fatalf("expected 'Bar' from header 'X-Foo', but got '%s'", c.Request().Header.Get("X-Foo"))
+					}
+					if c.Request().Header.Get("Gotenberg-Trace") != "123" {
+						t.Fatalf("expected '123' from header 'Gotenberg-Trace', but got '%s'", c.Request().Header.Get("Gotenberg-Trace"))
+					}
+					c.Response().Header().Set(echo.HeaderContentDisposition, `attachment; filename="bar.txt"`)
+					c.Response().Header().Set(echo.HeaderContentType, "text/plain")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg: defaultDownloadFromCfg,
+			expectContext: &Context{
+				values: map[string][]string{
+					"foo": {"foo"},
+					"downloadFrom": {
+						`[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`,
+					},
+				},
+				files: map[string]string{
+					"foo.txt": "foo.txt",
+					"bar.txt": "bar.txt", // downloadFrom.
+				},
+			},
+			expectError:     false,
+			expectHttpError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.downloadFromSrv != nil {
+				go func() {
+					err := tc.downloadFromSrv.Start(":80")
+					if !errors.Is(err, http.ErrServerClosed) {
+						t.Error(err)
+						return
+					}
+				}()
+				defer func() {
+					err := tc.downloadFromSrv.Shutdown(context.TODO())
+					if err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+
+			handler := func(c echo.Context) error {
+				ctx, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second, tc.downloadFromCfg, "Gotenberg-Trace", "123")
+				defer cancel()
+				// Context already cancelled.
+				defer cancel()
+
+				if err != nil {
+					return err
+				}
+
+				if tc.expectContext != nil {
+					if !reflect.DeepEqual(tc.expectContext.values, ctx.values) {
+						t.Fatalf("expected context.values to be %v but got %v", tc.expectContext.values, ctx.values)
+					}
+					if len(tc.expectContext.files) != len(ctx.files) {
+						t.Fatalf("expected context.files to contain %d items but got %d", len(tc.expectContext.files), len(ctx.files))
+					}
+					for key, value := range tc.expectContext.files {
+						if !strings.HasSuffix(ctx.files[key], value) {
+							t.Fatalf("expected context.files to contain '%s' but got '%s'", value, ctx.files[key])
+						}
+					}
+				}
+
+				return nil
+			}
+
+			recorder := httptest.NewRecorder()
+
+			srv := echo.New()
+			srv.HideBanner = true
+			srv.HidePort = true
+
+			c := srv.NewContext(tc.request, recorder)
+			err := handler(c)
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var httpErr HttpError
+			isHttpError := errors.As(err, &httpErr)
+
+			if tc.expectHttpError && !isHttpError {
+				t.Errorf("expected an HTTP error but got: %v", err)
+			}
+
+			if !tc.expectHttpError && isHttpError {
+				t.Errorf("expected no HTTP error but got one: %v", httpErr)
+			}
+
+			if err != nil && tc.expectHttpError && isHttpError {
+				status, _ := httpErr.HttpError()
+				if status != tc.expectHttpStatus {
+					t.Errorf("expected %d as HTTP status code but got %d", tc.expectHttpStatus, status)
+				}
+			}
+		})
+	}
+}
+
+func TestContext_Request(t *testing.T) {
+	request := httptest.NewRequest(http.MethodPost, "/", nil)
+	recorder := httptest.NewRecorder()
+	c := echo.New().NewContext(request, recorder)
+
+	ctx := &Context{
+		echoCtx: c,
+	}
+
+	if !reflect.DeepEqual(ctx.Request(), c.Request()) {
+		t.Errorf("expected %v but got %v", ctx.Request(), c.Request())
+	}
+}
+
+func TestContext_FormData(t *testing.T) {
+	ctx := &Context{
+		values: map[string][]string{
+			"foo": {"foo"},
+		},
+		files: map[string]string{
+			"foo.txt": "/foo.txt",
+		},
+	}
+
+	actual := ctx.FormData()
+	expect := &FormData{
+		values: ctx.values,
+		files:  ctx.files,
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %+v but got %+v", expect, actual)
+	}
+}
+
+func TestContext_GeneratePath(t *testing.T) {
+	ctx := &Context{
+		dirPath: "/foo",
+	}
+
+	path := ctx.GeneratePath(".pdf")
+	if !strings.HasPrefix(path, ctx.dirPath) {
+		t.Errorf("expected '%s' to start with '%s'", path, ctx.dirPath)
+	}
+}
+
+func TestContext_Rename(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		expectError bool
+	}{
+		{
+			scenario: "failure",
+			ctx: &Context{pathRename: &gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return errors.New("cannot rename")
+			}}},
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			ctx: &Context{pathRename: &gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return nil
+			}}},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.ctx.Rename("", "")
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestContext_AddOutputPaths(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		path        string
+		expectCount int
+		expectError bool
+	}{
+		{
+			scenario:    "ErrContextAlreadyClosed",
+			ctx:         &Context{cancelled: true},
+			expectCount: 0,
+			expectError: true,
+		},
+		{
+			scenario:    "ErrOutOfBoundsOutputPath",
+			ctx:         &Context{dirPath: "/foo"},
+			path:        "/bar/foo.txt",
+			expectCount: 0,
+			expectError: true,
+		},
+		{
+			scenario:    "success",
+			ctx:         &Context{dirPath: "/foo"},
+			path:        "/foo/foo.txt",
+			expectCount: 1,
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.ctx.AddOutputPaths(tc.path)
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if len(tc.ctx.outputPaths) != tc.expectCount {
+				t.Errorf("expected %d output paths but got %d", tc.expectCount, len(tc.ctx.outputPaths))
+			}
+		})
+	}
+}
+
+func TestContext_Log(t *testing.T) {
+	expect := zap.NewNop()
+	ctx := Context{logger: expect}
+	actual := ctx.Log()
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestContext_BuildOutputFile(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		expectError bool
+	}{
+		{
+			scenario:    "ErrContextAlreadyClosed",
+			ctx:         &Context{cancelled: true},
+			expectError: true,
+		},
+		{
+			scenario:    "no output path",
+			ctx:         &Context{},
+			expectError: true,
+		},
+		{
+			scenario:    "success: one output path",
+			ctx:         &Context{outputPaths: []string{"foo.txt"}},
+			expectError: false,
+		},
+		{
+			scenario:    "cannot archive: invalid output paths",
+			ctx:         &Context{outputPaths: []string{"foo.txt", "foo.pdf"}},
+			expectError: true,
+		},
+		{
+			scenario: "success: many output paths",
+			ctx: &Context{
+				outputPaths: []string{
+					"/tests/test/testdata/api/sample1.txt",
+					"/tests/test/testdata/api/sample1.txt",
+				},
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := gotenberg.NewFileSystem()
+			dirPath, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected no erro 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)
+				}
+			}()
+
+			tc.ctx.dirPath = dirPath
+			tc.ctx.logger = zap.NewNop()
+
+			_, err = tc.ctx.BuildOutputFile()
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestContext_OutputFilename(t *testing.T) {
+	for _, tc := range []struct {
+		scenario             string
+		ctx                  *Context
+		outputPath           string
+		expectOutputFilename string
+	}{
+		{
+			scenario: "with Gotenberg-Output-Filename header",
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				c.Request().Header.Set("Gotenberg-Output-Filename", "foo")
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/bar.txt",
+			expectOutputFilename: "foo.txt",
+		},
+		{
+			scenario: "without custom filename",
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/foo.txt",
+			expectOutputFilename: "foo.txt",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			actual := tc.ctx.OutputFilename(tc.outputPath)
+
+			if actual != tc.expectOutputFilename {
+				t.Errorf("expected '%s' but got '%s'", tc.expectOutputFilename, actual)
+			}
+		})
+	}
+}

pkg/modules/api/doc.go

@@ -0,0 +1,3 @@
+// Package api provides a module which is an HTTP server. Other modules may
+// add multipart/form-data routes, middlewares, and health checks.
+package api

pkg/modules/api/errors.go

@@ -0,0 +1,77 @@
+package api
+
+// Credits: https://www.joeshaw.org/error-handling-in-go-http-applications.
+
+// HttpError is an interface allowing to retrieve the HTTP details of an error.
+type HttpError interface {
+	HttpError() (int, string)
+}
+
+// SentinelHttpError is the HTTP sidekick of an error.
+type SentinelHttpError struct {
+	status  int
+	message string
+}
+
+// NewSentinelHttpError creates a [SentinelHttpError]. The message will be sent
+// as the response's body if returned from a handler, so make sure to not leak
+// sensible information.
+func NewSentinelHttpError(status int, message string) SentinelHttpError {
+	return SentinelHttpError{
+		status:  status,
+		message: message,
+	}
+}
+
+// Error returns the message.
+func (err SentinelHttpError) Error() string {
+	return err.message
+}
+
+// HttpError returns the status and message.
+func (err SentinelHttpError) HttpError() (int, string) {
+	return err.status, err.message
+}
+
+// sentinelWrappedError contains both the error which will logged and the
+// sidekick [SentinelHttpError].
+type sentinelWrappedError struct {
+	error
+	sentinel SentinelHttpError
+}
+
+func (w sentinelWrappedError) Is(err error) bool {
+	return w.sentinel == err
+}
+
+func (w sentinelWrappedError) HttpError() (int, string) {
+	return w.sentinel.HttpError()
+}
+
+// WrapError wraps the given error with a [SentinelHttpError]. The wrapped
+// error will be displayed in a log, while the [SentinelHttpError] will be sent
+// in the response.
+//
+//	return api.WrapError(
+//	  // This first error will be logged.
+//	  fmt.Errorf("my action: %w", err),
+//	  // The HTTP error will be sent as a response.
+//	  api.NewSentinelHttpError(
+//	    http.StatusForbidden,
+//	    "Hey, you did something wrong!"
+//	  ),
+//	)
+func WrapError(err error, sentinel SentinelHttpError) error {
+	return sentinelWrappedError{
+		error:    err,
+		sentinel: sentinel,
+	}
+}
+
+// Interface guards.
+var (
+	_ error     = (*SentinelHttpError)(nil)
+	_ HttpError = (*SentinelHttpError)(nil)
+	_ error     = (*sentinelWrappedError)(nil)
+	_ HttpError = (*sentinelWrappedError)(nil)
+)

pkg/modules/api/errors_test.go

@@ -0,0 +1,108 @@
+package api
+
+import (
+	"errors"
+	"net/http"
+	"reflect"
+	"testing"
+)
+
+func TestNewSentinelHttpError(t *testing.T) {
+	actual := NewSentinelHttpError(http.StatusInternalServerError, "foo")
+	expect := SentinelHttpError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestSentinelHttpError_Error(t *testing.T) {
+	err := SentinelHttpError{
+		message: "foo",
+	}
+
+	actual := err.Error()
+	expect := "foo"
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestSentinelHttpError_HttpError(t *testing.T) {
+	actualStatus, actualMessage := SentinelHttpError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}.HttpError()
+
+	expectStatus := http.StatusInternalServerError
+	expectMessage := "foo"
+
+	if actualStatus != expectStatus {
+		t.Errorf("expected %d but got %d", expectStatus, actualStatus)
+	}
+
+	if actualMessage != expectMessage {
+		t.Errorf("expected '%s' but got '%s'", expectMessage, actualMessage)
+	}
+}
+
+func TestSentinelWrappedError_Is(t *testing.T) {
+	errSentinel := SentinelHttpError{}
+
+	err := sentinelWrappedError{
+		error:    errors.New("foo"),
+		sentinel: errSentinel,
+	}
+
+	if !err.Is(errSentinel) {
+		t.Error("expected true")
+	}
+}
+
+func TestSentinelWrappedError_HttpError(t *testing.T) {
+	expectStatus, expectMessage := SentinelHttpError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	}.HttpError()
+
+	actualStatus, actualMessage := sentinelWrappedError{
+		error: errors.New("foo"),
+		sentinel: SentinelHttpError{
+			status:  http.StatusInternalServerError,
+			message: "foo",
+		},
+	}.HttpError()
+
+	if actualStatus != expectStatus {
+		t.Errorf("expected %d but got %d", expectStatus, actualStatus)
+	}
+
+	if actualMessage != expectMessage {
+		t.Errorf("expected '%s' but got '%s'", expectMessage, actualMessage)
+	}
+}
+
+func TestWrapError(t *testing.T) {
+	errFoo := errors.New("foo")
+
+	expect := sentinelWrappedError{
+		error: errFoo,
+		sentinel: SentinelHttpError{
+			status:  http.StatusInternalServerError,
+			message: "foo",
+		},
+	}
+
+	actual := WrapError(errFoo, SentinelHttpError{
+		status:  http.StatusInternalServerError,
+		message: "foo",
+	})
+
+	if !reflect.DeepEqual(actual, expect) {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}

pkg/modules/api/formdata.go

@@ -0,0 +1,528 @@
+package api
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.uber.org/multierr"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+// FormData is a helper for validating and hydrating values from a
+// "multipart/form-data" request.
+//
+//	form := ctx.FormData()
+type FormData struct {
+	values map[string][]string
+	files  map[string]string
+	errors error
+}
+
+// Validate returns nil or an error related to the [FormData] values, with a
+// [SentinelHttpError] (status code 400, errors' details as message) wrapped
+// inside.
+//
+//	var foo string
+//
+//	err := ctx.FormData().
+//	   MandatoryString("foo", &foo, "bar").
+//	   Validate()
+func (form *FormData) Validate() error {
+	if form.errors == nil {
+		return nil
+	}
+
+	return WrapError(
+		form.errors,
+		NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid form data: %s", form.errors)),
+	)
+}
+
+// String binds a form field to a string variable.
+//
+//	var foo string
+//
+//	ctx.FormData().String("foo", &foo, "bar")
+func (form *FormData) String(key string, target *string, defaultValue string) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryString binds a form field to a string variable. It populates
+// an error if the value is empty or the "key" does not exist.
+//
+//	var foo string
+//
+//	ctx.FormData().MandatoryString("foo", &foo)
+func (form *FormData) MandatoryString(key string, target *string) *FormData {
+	return form.mustMandatoryField(key, target)
+}
+
+// Bool binds a form field to a bool variable. It populates an error if
+// the value is not bool.
+//
+//	var foo bool
+//
+//	ctx.FormData().Bool("foo", &foo, true)
+func (form *FormData) Bool(key string, target *bool, defaultValue bool) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryBool binds a form field to a bool variable. It populates an
+// error if the value is not bool, is empty, or the "key" does not exist.
+//
+//	var foo bool
+//
+//	ctx.FormData().MandatoryBool("foo", &foo)
+func (form *FormData) MandatoryBool(key string, target *bool) *FormData {
+	return form.mustMandatoryField(key, target)
+}
+
+// Int binds a form field to an int variable. It populates an error if the
+// value is not int.
+//
+//	var foo int
+//
+//	ctx.FormData().Int("foo", &foo, 2)
+func (form *FormData) Int(key string, target *int, defaultValue int) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryInt binds a form field to an int variable. It populates an
+// error if the value is not int, is empty, or the "key" does not exist.
+//
+//	var foo int
+//
+//	ctx.FormData().MandatoryInt("foo", &foo)
+func (form *FormData) MandatoryInt(key string, target *int) *FormData {
+	return form.mustMandatoryField(key, target)
+}
+
+// Float64 binds a form field to a float64 variable. It populates an error
+// if the value is not float64.
+//
+//	var foo float64
+//
+//	ctx.FormData().Float64("foo", &foo, 2.0)
+func (form *FormData) Float64(key string, target *float64, defaultValue float64) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryFloat64 binds a form field to a float64 variable. It populates
+// an error if the is not float64, is empty, or the "key" does not exist.
+//
+//	var foo float64
+//
+//	ctx.FormData().MandatoryFloat64("foo", &foo)
+func (form *FormData) MandatoryFloat64(key string, target *float64) *FormData {
+	return form.mustMandatoryField(key, target)
+}
+
+// Duration binds a form field to a time.Duration variable. It populates
+// an error if the form field is not time.Duration.
+//
+//	var foo time.Duration
+//
+//	ctx.FormData().Duration("foo", &foo, time.Duration(2) * time.Second)
+func (form *FormData) Duration(key string, target *time.Duration, defaultValue time.Duration) *FormData {
+	return form.mustValue(key, target, defaultValue)
+}
+
+// MandatoryDuration binds a form field to a time.Duration variable. It
+// populates an error if the value is not time.Duration, is empty, or the "key"
+// does not exist.
+//
+//	var foo time.Duration
+//
+//	ctx.FormData().MandatoryDuration("foo", &foo)
+func (form *FormData) MandatoryDuration(key string, target *time.Duration) *FormData {
+	return form.mustMandatoryField(key, target)
+}
+
+// Inches binds a form field to a float64 variable. It populates an error
+// if the value cannot be computed back to inches.
+//
+//	var foo float64
+//
+//	ctx.FormData().Inches("foo", &foo, 2.0)
+func (form *FormData) Inches(key string, target *float64, defaultValue float64) *FormData {
+	form.inches(key, target)
+	if *target == -math.MaxFloat64 {
+		*target = defaultValue
+	}
+	return form
+}
+
+// MandatoryInches binds a form field to a float64 variable. It populates
+// an error if the value cannot be computed back to inches, is empty, or the
+// "key" does not exist.
+//
+//	var foo float64
+//
+//	ctx.FormData().MandatoryInches("foo", &foo)
+func (form *FormData) MandatoryInches(key string, target *float64) *FormData {
+	val, ok := form.values[key]
+	if !ok || val[0] == "" {
+		form.append(
+			fmt.Errorf("form field '%s' is required", key),
+		)
+		return form
+	}
+	return form.inches(key, target)
+}
+
+// inches tries to compute a string value to inches.
+func (form *FormData) inches(key string, target *float64) *FormData {
+	var value string
+	form.mustValue(key, &value, "")
+
+	if value == "" {
+		*target = -math.MaxFloat64
+		return form
+	}
+
+	for _, unit := range []string{"pt", "px", "in", "mm", "cm", "pc"} {
+		if !strings.HasSuffix(value, unit) {
+			continue
+		}
+
+		val, err := strconv.ParseFloat(strings.TrimSuffix(value, unit), 64)
+		if err != nil {
+			form.append(
+				fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+			)
+			return form
+		}
+
+		switch unit {
+		case "pt":
+			*target = val * (1.0 / 72.0)
+		case "px":
+			*target = val * (1.0 / 96.0)
+		case "in":
+			*target = val
+		case "mm":
+			*target = val * (1.0 / 25.4)
+		case "cm":
+			*target = val * (1.0 / 2.54)
+		case "pc":
+			*target = val * (1.0 / 6.0)
+		}
+
+		return form
+	}
+
+	val, err := strconv.ParseFloat(value, 64)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+		return form
+	}
+
+	*target = val
+	return form
+}
+
+// Custom helps to define a custom binding function for a form field.
+//
+//	var foo map[string]string
+//
+//	ctx.FormData().Custom("foo", func(value string) error {
+//	  if value == "" {
+//	    foo = "bar"
+//
+//	    return nil
+//	  }
+//
+//	  err := json.Unmarshal([]byte(value), &foo)
+//	  if err != nil {
+//	    return fmt.Errorf("unmarshal foo: %w", err)
+//	  }
+//
+//	  return nil
+//	})
+func (form *FormData) Custom(key string, assign func(value string) error) *FormData {
+	var value string
+	form.mustValue(key, &value, "")
+
+	err := assign(value)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// MandatoryCustom helps to define a custom binding function for a form field.
+// It populates an error if the value is empty or the "key" does not exist.
+//
+//	var foo map[string]string
+//
+//	ctx.FormData().MandatoryCustom("foo", func(value string) error {
+//	  err := json.Unmarshal([]byte(value), &foo)
+//	  if err != nil {
+//	    return fmt.Errorf("unmarshal foo: %w", err)
+//	  }
+//
+//	  return nil
+//	})
+func (form *FormData) MandatoryCustom(key string, assign func(value string) error) *FormData {
+	var value string
+	form.mustMandatoryField(key, &value)
+
+	if value == "" {
+		return form
+	}
+
+	err := assign(value)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// Path binds the absolute path of a form data file to a string variable.
+//
+//	var path string
+//
+//	ctx.FormData().Path("foo.txt", &path)
+func (form *FormData) Path(filename string, target *string) *FormData {
+	return form.path(filename, target)
+}
+
+// MandatoryPath binds the absolute path ofa  form data file to a string
+// variable. It populates an error if the file does not exist.
+//
+//	var path string
+//
+//	ctx.FormData().MandatoryPath("foo.txt", &path)
+func (form *FormData) MandatoryPath(filename string, target *string) *FormData {
+	return form.mandatoryPath(filename, target)
+}
+
+// Content binds the content of a form data file to a string variable.
+//
+//	var content string
+//
+//	ctx.FormData().Content("foo.txt", &content, "bar")
+func (form *FormData) Content(filename string, target *string, defaultValue string) *FormData {
+	var path string
+	form.path(filename, &path)
+
+	if path == "" {
+		*target = defaultValue
+
+		return form
+	}
+
+	return form.readFile(path, filename, target)
+}
+
+// MandatoryContent binds the content of a form data file to a string variable.
+// It populates an error if the file does not exist.
+//
+//	var content string
+//
+//	ctx.FormData().MandatoryContent("foo.txt", &content)
+func (form *FormData) MandatoryContent(filename string, target *string) *FormData {
+	var path string
+	form.mandatoryPath(filename, &path)
+
+	if path == "" {
+		return form
+	}
+
+	return form.readFile(path, filename, target)
+}
+
+// Paths binds the absolute paths of form data files, according to a list of
+// file extensions, to a string slice variable.
+//
+//	var paths []string
+//
+//	ctx.FormData().Paths([]string{".txt"}, &paths)
+func (form *FormData) Paths(extensions []string, target *[]string) *FormData {
+	return form.paths(extensions, target)
+}
+
+// MandatoryPaths binds the absolute paths of form data files, according to a
+// list of file extensions, to a string slice variable. It populates an error
+// if there is no file for given file extensions.
+//
+//	var paths []string
+//
+//	ctx.FormData().MandatoryPaths([]string{".txt"}, &paths)
+func (form *FormData) MandatoryPaths(extensions []string, target *[]string) *FormData {
+	form.paths(extensions, target)
+
+	if len(*target) > 0 {
+		return form
+	}
+
+	form.append(
+		fmt.Errorf("no form file found for extensions: %v", extensions),
+	)
+
+	return form
+}
+
+// paths binds the absolute paths of form data files, according to a list of
+// file extensions, to a string slice variable.
+func (form *FormData) paths(extensions []string, target *[]string) *FormData {
+	for filename, path := range form.files {
+		for _, ext := range extensions {
+			// See https://github.com/gotenberg/gotenberg/issues/228.
+			if strings.ToLower(filepath.Ext(filename)) == ext {
+				*target = append(*target, path)
+			}
+		}
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/139.
+	sort.Sort(gotenberg.AlphanumericSort(*target))
+
+	return form
+}
+
+// append adds an error to the list of errors.
+func (form *FormData) append(err error) {
+	form.errors = multierr.Append(form.errors, err)
+}
+
+// mustValue binds the target interface with a form field. If the value is
+// empty or the "key" does not exist, it binds the default value. Currently,
+// only the string, bool, int, float64 and time.Duration types are bindable.
+func (form *FormData) mustValue(key string, target interface{}, defaultValue interface{}) *FormData {
+	val, ok := form.values[key]
+
+	if !ok || val[0] == "" {
+		switch t := (target).(type) {
+		case *string:
+			*t = defaultValue.(string)
+		case *bool:
+			*t = defaultValue.(bool)
+		case *int:
+			*t = defaultValue.(int)
+		case *float64:
+			*t = defaultValue.(float64)
+		case *time.Duration:
+			*t = defaultValue.(time.Duration)
+		default:
+			panic("target type not supported")
+		}
+
+		return form
+	}
+
+	return form.mustAssign(key, val[0], target)
+}
+
+// mustMandatoryField binds the target interface with a form field. It
+// populates an error if the value is empty or the "key" does not exist.
+// Currently, only the string, bool, int, float64 and time.Duration types are
+// bindable.
+func (form *FormData) mustMandatoryField(key string, target interface{}) *FormData {
+	val, ok := form.values[key]
+
+	if !ok || val[0] == "" {
+		form.append(
+			fmt.Errorf("form field '%s' is required", key),
+		)
+
+		return form
+	}
+
+	form.mustAssign(key, val[0], target)
+
+	return form
+}
+
+// mustAssign parses the string value and tries to convert it to the target
+// interface real type. Currently, only the string, bool, int, float64 and
+// time.Duration types are bindable.
+func (form *FormData) mustAssign(key, value string, target interface{}) *FormData {
+	var err error
+
+	switch t := (target).(type) {
+	case *string:
+		*t = value
+	case *bool:
+		*t, err = strconv.ParseBool(value)
+	case *int:
+		*t, err = strconv.Atoi(value)
+	case *float64:
+		*t, err = strconv.ParseFloat(value, 64)
+	case *time.Duration:
+		*t, err = time.ParseDuration(value)
+	default:
+		panic("target type not supported")
+	}
+
+	if err != nil {
+		form.append(
+			fmt.Errorf("form field '%s' is invalid (got '%s', resulting to %w)", key, value, err),
+		)
+	}
+
+	return form
+}
+
+// path binds the absolute path of a form data file to a string variable.
+func (form *FormData) path(filename string, target *string) *FormData {
+	for name, path := range form.files {
+		// See https://github.com/gotenberg/gotenberg/issues/228.
+		nameLowerExt := strings.TrimSuffix(name, filepath.Ext(name)) + strings.ToLower(filepath.Ext(name))
+		if name == filename || nameLowerExt == filename {
+			*target = path
+			return form
+		}
+	}
+
+	return form
+}
+
+// mandatoryPath binds the absolute path of a form data file to a string
+// variable. It populates an error if the file does not exist.
+func (form *FormData) mandatoryPath(filename string, target *string) *FormData {
+	form.path(filename, target)
+
+	if *target != "" {
+		return form
+	}
+
+	form.append(
+		fmt.Errorf("form file '%s' is required", filename),
+	)
+
+	return form
+}
+
+// readFile binds the content of a file to a string variable. It populates an
+// error if it fails to read the file content.
+func (form *FormData) readFile(path, filename string, target *string) *FormData {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		form.append(
+			fmt.Errorf("form file '%s' is invalid (%w)", filename, err),
+		)
+
+		return form
+	}
+
+	*target = string(b)
+
+	return form
+}