Database setup for the Website service (#13)

This PR contains the work done to introduce a _Fluent_-based persistence layer for the Website service, selectable at runtime alongside the existing in-memory default, plus the local dev tooling and docs to support it.

To provide further details about the work:

* Persistence package
  * The `Driver` and `TLS` enumerations
  * The `Configuration` type
  * The `Service` factory that builds the  service
  * `PrepareDB` for migrations registration
  * The `Probe` for readiness checks.

* App integration
  *  Builds the driver, registers migrations, and attaches `Fluent` to the service lifecycle so it starts/stops with the HTTP server.
  * Migrate-on-boot is gated to the in-memory backend; MySQL/MariaDB is migrated out of band via --database-migrate so shared databases never race on startup.
  * The `ConfigReader+Properties` extension maps database.* config keys onto the driver.

* Library
  * Added database configuration constants.
  * The `HealthController` controller gains a readiness probe: `GET /health/ready` checks whether the database is reachable, separate from the existing liveness check.

* Others
  * Updated the `docker-compose` files to support a database service behind a database profile, and hardened for local development
  * New database targets on the `Makefile` file and overall documentation updated
  * Updated the `.env.local`, `Dockerfile`, and `README` files to document the persistence workflow, config keys, and local DB commands

Reviewed-on: rock-n-code/loud-amsterdam#13
Co-authored-by: Javier Cicchelli <javier@rock-n-code.com>
Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>

Packages/Localization/Sources/Public/Methods/Localize.swift

@@ -0,0 +1,61 @@
+import Foundation
+
+/// A reusable, bundle-bound localizer that resolves String Catalog entries for an explicit locale.
+///
+/// A server has no single "current" locale, so each lookup must name the locale to use. An instance
+/// is bound to the bundle whose catalog holds the strings, then invoked like a function to resolve a
+/// key in a chosen locale.
+public struct Localize: Sendable {
+
+    // MARK: Properties
+
+    /// The backend that resolves keys against the catalog.
+    private let resolver: any CatalogResolving
+
+    // MARK: Initializers
+
+    /// Creates a localizer backed by the String Catalog in the given bundle.
+    /// - Parameters:
+    ///   - bundle: the bundle whose String Catalog contains the keys to resolve.
+    ///   - table: the name of the String Catalog resource, without the `.xcstrings` extension.
+    public init(
+        bundle: Bundle,
+        table: String = "Localizable"
+    ) {
+        self.init(resolver: StringCatalog(
+            bundle: bundle,
+            table: table
+        ))
+    }
+
+    /// Creates a localizer backed by the given resolver.
+    ///
+    /// The seam for tests and alternative backends; the public API resolves against a bundled catalog.
+    /// - Parameter resolver: the backend that resolves keys to localized strings.
+    init(
+        resolver: any CatalogResolving
+    ) {
+        self.resolver = resolver
+    }
+
+    // MARK: Methods
+
+    /// Resolves a catalog key in the given locale.
+    ///
+    /// Invoked by calling the instance directly, for example `localize("index.title", locale: locale)`.
+    /// - Parameters:
+    ///   - key: the String Catalog key to look up.
+    ///   - locale: the locale to resolve the key in.
+    /// - Returns: the localized string for the locale, the source-language string when the locale has no
+    ///   entry, or the key itself when the catalog has no entry for it.
+    public func callAsFunction(
+        _ key: String,
+        locale: Locale
+    ) -> String {
+        resolver.string(
+            for: key,
+            in: locale
+        )
+    }
+
+}

Packages/Localization/Sources/Public/Methods/Negotiate.swift

@@ -0,0 +1,142 @@
+import Foundation
+
+/// Negotiates the best supported language for a request from its `Accept-Language` header.
+///
+/// Bound to a bundle's catalog languages via ``LanguageList``, an instance is invoked like a
+/// function — through ``callAsFunction(acceptLanguage:)`` — to resolve a header value to a
+/// supported language identifier, falling back to the default language.
+public struct Negotiate: Sendable {
+
+    // MARK: Properties
+
+    /// The supported languages and default language, derived from the bundle's String Catalog.
+    private let list: LanguageList
+
+    // MARK: Initializers
+
+    /// Creates a language negotiator backed by the given bundle's String Catalog.
+    /// - Parameter bundle: the bundle whose String Catalog defines the supported languages.
+    public init(
+        bundle: Bundle
+    ) {
+        self.list = .init(bundle: bundle)
+    }
+
+    // MARK: Methods
+
+    /// Picks the best supported language for the given `Accept-Language` header value.
+    ///
+    /// Invoked by calling the instance directly, for example `negotiate(acceptLanguage: header)`.
+    /// The header is split into its language tags (dropping any `q` weights), then each tag is matched
+    /// against the supported languages in order of preference — first by an exact match, then by its
+    /// primary language subtag, so `de-AT` resolves to a supported `de`. When the header is absent or
+    /// matches nothing, the default language is returned.
+    /// - Parameter acceptLanguage: the raw `Accept-Language` header value, if any.
+    /// - Returns: the identifier of the supported language to serve.
+    public func callAsFunction(
+        acceptLanguage language: String?
+    ) -> String {
+        guard let language else {
+            return list.default
+        }
+
+        let tags = tags(from: language)
+
+        guard !tags.isEmpty else {
+            return list.default
+        }
+
+        let supported = list.all
+
+        for tag in tags {
+            if let match = match(tag: tag, in: supported) {
+                return match
+            }
+        }
+
+        return list.default
+    }
+
+}
+
+// MARK: - Helpers
+
+private extension Negotiate {
+
+    // MARK: Methods
+
+    /// Extracts the ordered language tags from an `Accept-Language` header value.
+    ///
+    /// Each comma-separated entry is reduced to its language tag by dropping the `;q=` weight, and
+    /// blank entries are removed. The original order is kept, which mirrors descending preference
+    /// closely enough for `preferredLocalizations(from:forPreferences:)` to resolve correctly.
+    /// - Parameter acceptLanguage: the raw `Accept-Language` header value.
+    /// - Returns: the ordered, weight-stripped language tags.
+    func tags(
+        from acceptLanguage: String
+    ) -> [String] {
+        acceptLanguage
+            .split(separator: .Separator.comma)
+            .map { entry in
+                entry
+                    .split(separator: .Separator.semicolon)
+                    .first
+                    .map(String.init)?
+                    .trimmingCharacters(in: .whitespaces)
+                ?? .empty
+            }
+            .filter { !$0.isEmpty }
+    }
+
+    /// Finds the supported language that best matches a single `Accept-Language` tag.
+    ///
+    /// An exact, case-insensitive match wins; otherwise the tag's primary subtag is matched against the
+    /// supported languages' primary subtags, so a regional tag such as `de-AT` resolves to `de`.
+    /// - Parameters:
+    ///   - tag: a single language tag from the header.
+    ///   - supported: the supported language identifiers.
+    /// - Returns: the matching supported language, or `nil` when the tag matches none.
+    func match(
+        tag: String,
+        in supported: [String]
+    ) -> String? {
+        let tag = tag.lowercased()
+
+        if let exact = supported.first(
+            where: { $0.lowercased() == tag }
+        ) {
+            return exact
+        }
+
+        let primary = tag.primarySubtag
+
+        return supported.first {
+            $0.lowercased().primarySubtag == primary
+        }
+    }
+
+}
+
+// MARK: - String+Extensions
+
+private extension String {
+    static let empty: String = ""
+
+    /// The primary language subtag, i.e. everything before the first `-` (`de-AT` becomes `de`).
+    var primarySubtag: String {
+        split(separator: .Separator.dash)
+            .first
+            .map(String.init)
+        ?? self
+    }
+}
+
+// MARK: - Constants
+
+private extension Character {
+    enum Separator {
+        static let comma: Character = ","
+        static let dash: Character = "-"
+        static let semicolon: Character = ";"
+    }
+}

Packages/Localization/Sources/Public/Types/LanguageList.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+/// The list of languages an app can serve, derived from a bundle's String Catalog.
+///
+/// The languages are read from the injected `bundle`'s String Catalog, so the catalog that ships in that bundle is the single source of truth: adding
+/// a language is a translation-only change — once a locale exists in the catalog, it appears in ``all`` with no code change required.
+public struct LanguageList: Sendable {
+
+    // MARK: Properties
+
+    /// The language served when none of the supported languages match a request.
+    ///
+    /// Should match the catalog bundle's development localization.
+    public let `default`: String
+
+    /// The backend that reports the available languages.
+    private let resolver: any CatalogResolving
+
+    // MARK: Initializers
+
+    /// Creates a language list backed by the given bundle.
+    /// - Parameters:
+    ///   - bundle: the bundle whose String Catalog defines the available languages.
+    ///   - default: the language served when none of the supported languages match. Defaults to `"en"`.
+    public init(
+        bundle: Bundle,
+        `default`: String = "en"
+    ) {
+        self.init(
+            resolver: StringCatalog(bundle: bundle),
+            default: `default`
+        )
+    }
+
+    /// Creates a language list backed by the given resolver.
+    ///
+    /// The seam for tests and alternative backends; the public API derives languages from a bundled catalog.
+    /// - Parameters:
+    ///   - resolver: the backend that reports the available languages.
+    ///   - default: the language served when none of the supported languages match.
+    init(
+        resolver: any CatalogResolving,
+        `default`: String = "en"
+    ) {
+        self.resolver = resolver
+        self.`default` = `default`
+    }
+
+    // MARK: Computed
+
+    /// Every language the bundle's String Catalog provides a localization for.
+    ///
+    /// The `Base` internationalization is excluded, as it is a development placeholder rather than a real language.
+    /// The result is sorted for a stable order.
+    public var all: [String] {
+        resolver
+            .languages
+            .filter { $0 != "Base" }
+            .sorted()
+    }
+
+}