sovrium 0.0.2

package/src/infrastructure/filesystem/copy-directory.ts

@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { readdir, mkdir } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+import { Effect, Data } from 'effect'
+import type { Dirent } from 'node:fs'
+
+/**
+ * File copy error - infrastructure layer error
+ */
+export class FileCopyError extends Data.TaggedError('FileCopyError')<{
+  readonly message: string
+  readonly cause?: unknown
+}> {}
+
+/**
+ * Copy a single file from source to destination using Bun's native file API
+ */
+const copyFile = (
+  sourcePath: string,
+  destPath: string
+): Effect.Effect<string, FileCopyError, never> =>
+  Effect.gen(function* () {
+    // Read file using Bun's native file API (faster and more idiomatic)
+    // arrayBuffer() preserves binary content exactly
+    const content = yield* Effect.tryPromise({
+      try: () => Bun.file(sourcePath).arrayBuffer(),
+      catch: (error) =>
+        new FileCopyError({
+          message: `Failed to read file ${sourcePath}`,
+          cause: error,
+        }),
+    })
+
+    // Write file using Bun.write (faster than Node.js fs/promises)
+    // Bun.write handles ArrayBuffer, Buffer, string, etc.
+    yield* Effect.tryPromise({
+      try: () => Bun.write(destPath, content),
+      catch: (error) =>
+        new FileCopyError({
+          message: `Failed to write file ${destPath}`,
+          cause: error,
+        }),
+    })
+
+    return destPath
+  })
+
+/**
+ * Create a directory at the destination
+ */
+const createDirectory = (destPath: string): Effect.Effect<void, FileCopyError, never> =>
+  Effect.tryPromise({
+    try: () => mkdir(destPath, { recursive: true }),
+    catch: (error) =>
+      new FileCopyError({
+        message: `Failed to create directory ${destPath}`,
+        cause: error,
+      }),
+  })
+
+/**
+ * Read directory entries
+ */
+const readDirectoryEntries = (
+  sourcePath: string
+): Effect.Effect<readonly Dirent[], FileCopyError, never> =>
+  Effect.tryPromise({
+    try: () => readdir(sourcePath, { withFileTypes: true }),
+    catch: (error) =>
+      new FileCopyError({
+        message: `Failed to read directory ${sourcePath}`,
+        cause: error,
+      }),
+  })
+
+/**
+ * Recursively copy directory contents from source to destination
+ *
+ * This function:
+ * 1. Preserves directory structure
+ * 2. Handles binary files correctly (no corruption)
+ * 3. Skips the assets/ directory in destination (reserved for CSS)
+ * 4. Returns list of copied file paths (relative to destination)
+ *
+ * @param source - Source directory path
+ * @param destination - Destination directory path
+ * @returns Effect with list of copied file paths (relative to destination)
+ */
+export const copyDirectory = (
+  source: string,
+  destination: string
+): Effect.Effect<readonly string[], FileCopyError, never> => {
+  // Recursive copy function that returns list of copied files
+  const copyRecursive = (
+    sourcePath: string,
+    destPath: string
+  ): Effect.Effect<readonly string[], FileCopyError, never> =>
+    Effect.gen(function* () {
+      const entries = yield* readDirectoryEntries(sourcePath)
+
+      // Process entries and collect copied files immutably
+      const copiedFiles = yield* Effect.forEach(
+        entries,
+        (entry) =>
+          Effect.gen(function* () {
+            const sourceEntryPath = join(sourcePath, entry.name)
+            const destEntryPath = join(destPath, entry.name)
+
+            if (entry.isDirectory()) {
+              yield* createDirectory(destEntryPath)
+              return yield* copyRecursive(sourceEntryPath, destEntryPath)
+            }
+
+            if (entry.isFile()) {
+              yield* copyFile(sourceEntryPath, destEntryPath)
+              const relativePath = relative(destination, destEntryPath)
+              return [relativePath] as readonly string[]
+            }
+
+            // Not a directory or file (e.g., symlink) - skip
+            return [] as readonly string[]
+          }),
+        { concurrency: 'unbounded' }
+      )
+
+      return copiedFiles.flat() as readonly string[]
+    })
+
+  return copyRecursive(source, destination)
+}

package/src/infrastructure/layers/app-layer.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Layer } from 'effect'
+import { createAuthLayer } from '@/infrastructure/auth/better-auth'
+import { CSSCompilerLive } from '@/infrastructure/css/css-compiler-live'
+import { DatabaseLive } from '@/infrastructure/database/drizzle/layer'
+import { AuthRepositoryLive } from '@/infrastructure/database/repositories/auth-repository-live'
+import { DevToolsLayerOptional } from '@/infrastructure/devtools'
+import { PageRendererLive } from '@/infrastructure/layers/page-renderer-layer'
+import { LoggerLive } from '@/infrastructure/logging/logger'
+import { ServerFactoryLive } from '@/infrastructure/server/server-factory-live'
+import { StaticSiteGeneratorLive } from '@/infrastructure/server/static-site-generator-live'
+import type { Auth as AuthConfig } from '@/domain/models/app/auth'
+
+/**
+ * Application layer composition
+ *
+ * Combines all live service implementations into a single Layer
+ * that can be provided to Application use cases.
+ *
+ * This is the production dependency wiring point - swap out
+ * individual layers here for testing or different environments.
+ *
+ * @example
+ * ```typescript
+ * // In src/index.ts (production)
+ * const program = startServer(appConfig).pipe(
+ *   Effect.provide(createAppLayer(appConfig.auth))
+ * )
+ *
+ * // In tests (with mocks)
+ * const TestLayer = Layer.mergeAll(MockServerFactory, MockPageRenderer)
+ * const program = startServer(appConfig).pipe(
+ *   Effect.provide(TestLayer)
+ * )
+ * ```
+ */
+export const createAppLayer = (authConfig?: AuthConfig) =>
+  Layer.mergeAll(
+    createAuthLayer(authConfig),
+    DatabaseLive,
+    ServerFactoryLive,
+    PageRendererLive,
+    CSSCompilerLive,
+    StaticSiteGeneratorLive,
+    DevToolsLayerOptional,
+    LoggerLive,
+    AuthRepositoryLive
+  )
+
+/**
+ * Default application layer with default auth configuration
+ *
+ * @deprecated Use createAppLayer(authConfig) instead for app-specific configuration
+ */
+export const AppLayer = createAppLayer()

package/src/infrastructure/layers/page-renderer-layer.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Layer } from 'effect'
+import { PageRenderer } from '@/application/ports/services/page-renderer'
+import { renderErrorPage, renderNotFoundPage } from '@/presentation/rendering/render-error-pages'
+import { renderHomePage, renderPage } from '@/presentation/rendering/render-homepage'
+
+/**
+ * Live implementation of PageRenderer using React SSR
+ *
+ * This Layer provides production page rendering logic,
+ * wrapping the presentation layer rendering functions in an
+ * Effect Context service.
+ *
+ * Located in Infrastructure layer because Effect Layer "Live"
+ * implementations are adapters (ports/adapters pattern).
+ * Infrastructure adapters CAN depend on presentation utilities
+ * for rendering logic.
+ *
+ * The implementation uses Layer.succeed because all rendering
+ * functions are pure and synchronous (no async operations).
+ *
+ * @example
+ * ```typescript
+ * // Provide PageRendererLive to use cases
+ * const program = startServer(appConfig).pipe(
+ *   Effect.provide(PageRendererLive)
+ * )
+ * ```
+ */
+export const PageRendererLive = Layer.succeed(PageRenderer, {
+  renderHome: renderHomePage,
+  renderPage,
+  renderNotFound: renderNotFoundPage,
+  renderError: renderErrorPage,
+})

package/src/infrastructure/logging/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+export { logError, logWarning, logInfo, logDebug, createModuleLogger } from './logger'

package/src/infrastructure/logging/logger.ts

@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Console, Context, Effect, Layer } from 'effect'
+
+/**
+ * Logger service for application-wide logging
+ *
+ * Provides structured logging with log levels:
+ * - debug: Detailed diagnostic information
+ * - info: General informational messages
+ * - warn: Warning messages for potential issues
+ * - error: Error messages for failures
+ */
+export class Logger extends Context.Tag('Logger')<
+  Logger,
+  {
+    readonly debug: (message: string, ...args: unknown[]) => Effect.Effect<void>
+    readonly info: (message: string, ...args: unknown[]) => Effect.Effect<void>
+    readonly warn: (message: string, ...args: unknown[]) => Effect.Effect<void>
+    readonly error: (message: string, error?: unknown) => Effect.Effect<void>
+  }
+>() {}
+
+/**
+ * Format log message with timestamp
+ */
+const formatLogMessage = (level: string, message: string): string => {
+  const timestamp = new Date().toISOString()
+  return `[${timestamp}] [${level}] ${message}`
+}
+
+/**
+ * Console-based logger implementation
+ *
+ * Uses Effect Console for output with structured formatting
+ * Format: [2025-01-15T10:30:00.000Z] [LEVEL] message
+ *
+ * Benefits of Effect Console over console.*:
+ * - Already Effect-based (no need to wrap in Effect.sync)
+ * - Testable via Console.setConsole for mocking
+ * - Integrates with Effect DevTools and tracing
+ * - Type-safe with better TypeScript inference
+ */
+export const LoggerLive = Layer.succeed(Logger, {
+  debug: (message, ...args) =>
+    Effect.gen(function* () {
+      if (process.env.LOG_LEVEL === 'debug' || process.env.NODE_ENV === 'development') {
+        yield* Console.debug(formatLogMessage('DEBUG', message), ...args)
+      }
+    }),
+
+  info: (message, ...args) => Console.log(formatLogMessage('INFO', message), ...args),
+
+  warn: (message, ...args) => Console.warn(formatLogMessage('WARN', message), ...args),
+
+  error: (message, error) =>
+    error
+      ? Console.error(formatLogMessage('ERROR', message), error)
+      : Console.error(formatLogMessage('ERROR', message)),
+})
+
+/**
+ * Silent logger for testing
+ *
+ * Discards all log messages
+ */
+export const LoggerSilent = Layer.succeed(Logger, {
+  debug: () => Effect.void,
+  info: () => Effect.void,
+  warn: () => Effect.void,
+  error: () => Effect.void,
+})
+
+// ============================================================================
+// Convenience Functions for Non-Effect Contexts
+// ============================================================================
+
+/**
+ * Convenience logging functions for non-Effect contexts
+ *
+ * These functions provide a bridge to use the Logger service from code that
+ * doesn't use Effect.gen (async callbacks, module initialization, etc.).
+ *
+ * Implementation: Thin wrapper around Logger service that automatically
+ * provides LoggerLive layer and runs the Effect synchronously.
+ *
+ * Why use this instead of console.*:
+ * 1. Consistent formatting with Logger service (timestamps, levels)
+ * 2. Single source of truth for logging implementation
+ * 3. Log levels for filtering (error, warning, info, debug)
+ * 4. Future-proof: easy to add log aggregation, tracing, etc.
+ *
+ * @example
+ * ```typescript
+ * import { logError, logWarning, logInfo } from '@/infrastructure/logging/logger'
+ *
+ * // In a non-Effect callback (e.g., Better Auth email handler)
+ * try {
+ *   await sendEmail(...)
+ * } catch (error) {
+ *   logError('[EMAIL] Failed to send email', error)
+ * }
+ * ```
+ */
+
+/**
+ * Run a Logger service Effect synchronously with LoggerLive layer
+ *
+ * This is safe for logging effects as they don't require async operations
+ * and complete synchronously.
+ */
+const runLogEffect = <A>(effect: Effect.Effect<A, never, Logger>): void => {
+  // eslint-disable-next-line functional/no-expression-statements -- Side effect for logging
+  Effect.runSync(effect.pipe(Effect.provide(LoggerLive)))
+}
+
+/**
+ * Log an error message with optional cause
+ *
+ * Use for unexpected errors, exceptions, and failure conditions.
+ *
+ * @param message - Error message (include context like [EMAIL], [AUTH])
+ * @param cause - Optional error cause for stack trace
+ */
+export const logError = (message: string, cause?: unknown): void => {
+  runLogEffect(
+    Effect.gen(function* () {
+      const logger = yield* Logger
+      yield* logger.error(message, cause)
+    })
+  )
+}
+
+/**
+ * Log a warning message
+ *
+ * Use for non-critical issues that should be addressed but don't
+ * prevent operation (missing optional config, deprecated usage, etc.).
+ *
+ * @param message - Warning message
+ */
+export const logWarning = (message: string): void => {
+  runLogEffect(
+    Effect.gen(function* () {
+      const logger = yield* Logger
+      yield* logger.warn(message)
+    })
+  )
+}
+
+/**
+ * Log an info message
+ *
+ * Use for notable events during normal operation (startup, config loaded, etc.).
+ *
+ * @param message - Info message
+ */
+export const logInfo = (message: string): void => {
+  runLogEffect(
+    Effect.gen(function* () {
+      const logger = yield* Logger
+      yield* logger.info(message)
+    })
+  )
+}
+
+/**
+ * Log a debug message
+ *
+ * Use for detailed debugging information (variable values, flow tracing).
+ * These are typically filtered out in production.
+ *
+ * @param message - Debug message
+ */
+export const logDebug = (message: string): void => {
+  runLogEffect(
+    Effect.gen(function* () {
+      const logger = yield* Logger
+      yield* logger.debug(message)
+    })
+  )
+}
+
+/**
+ * Create a logger with a fixed prefix for a specific module
+ *
+ * @example
+ * ```typescript
+ * const emailLogger = createModuleLogger('EMAIL')
+ * emailLogger.error('Failed to send') // Logs: [EMAIL] Failed to send
+ * emailLogger.warn('SMTP not configured')
+ * ```
+ */
+export const createModuleLogger = (module: string) => ({
+  error: (message: string, cause?: unknown) => logError(`[${module}] ${message}`, cause),
+  warning: (message: string) => logWarning(`[${module}] ${message}`),
+  info: (message: string) => logInfo(`[${module}] ${message}`),
+  debug: (message: string) => logDebug(`[${module}] ${message}`),
+})

package/src/infrastructure/schema/file-loader.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * File Loader - Infrastructure Layer
+ *
+ * File system I/O operations for loading schema files.
+ */
+
+import { detectFormat, getFileExtension, parseJsonContent, parseYamlContent } from '@/domain/utils'
+import type { AppEncoded } from '@/domain/models/app'
+
+/**
+ * Load and parse schema from a file (throws on error, no process.exit)
+ *
+ * @throws Error if file doesn't exist, format is unsupported, or parsing fails
+ */
+export const loadSchemaFromFile = async (filePath: string): Promise<AppEncoded> => {
+  const file = Bun.file(filePath)
+  const exists = await file.exists()
+
+  if (!exists) {
+    // eslint-disable-next-line functional/no-throw-statements
+    throw new Error(`File not found: ${filePath}`)
+  }
+
+  const format = detectFormat(filePath)
+
+  if (format === 'unsupported') {
+    const extension = getFileExtension(filePath)
+    // eslint-disable-next-line functional/no-throw-statements
+    throw new Error(`Unsupported file format: .${extension}. Supported: .json, .yaml, .yml`)
+  }
+
+  const content = await file.text()
+
+  return format === 'json' ? parseJsonContent(content) : parseYamlContent(content)
+}
+
+/**
+ * Check if a file exists
+ */
+export const fileExists = async (filePath: string): Promise<boolean> => Bun.file(filePath).exists()
+
+/**
+ * Read file content as text
+ */
+export const readFileContent = async (filePath: string): Promise<string> =>
+  Bun.file(filePath).text()

package/src/infrastructure/schema/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * Schema Infrastructure Module
+ *
+ * I/O operations for loading schemas from files and remote URLs.
+ */
+
+export { loadSchemaFromFile, fileExists, readFileContent } from './file-loader'
+export { fetchRemoteSchema } from './remote-loader'

package/src/infrastructure/schema/remote-loader.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * Remote Loader - Infrastructure Layer
+ *
+ * Network I/O operations for fetching schemas from remote URLs.
+ */
+
+import {
+  detectFormatFromContentType,
+  detectFormatFromUrl,
+  parseSchemaContent,
+} from '@/domain/utils'
+import type { AppEncoded } from '@/domain/models/app'
+
+/**
+ * Fetch and parse schema from a remote URL
+ *
+ * @throws Error if fetch fails or content cannot be parsed
+ */
+export const fetchRemoteSchema = async (url: string): Promise<AppEncoded> => {
+  try {
+    const response = await fetch(url)
+
+    if (!response.ok) {
+      // eslint-disable-next-line functional/no-throw-statements
+      throw new Error(`Failed to fetch schema from ${url}: HTTP ${response.status}`)
+    }
+
+    const contentType = response.headers.get('content-type') || ''
+    const content = await response.text()
+
+    // Try to detect format from Content-Type header, then URL extension
+    const format = detectFormatFromContentType(contentType) || detectFormatFromUrl(url)
+
+    return parseSchemaContent(content, format)
+  } catch (error) {
+    // eslint-disable-next-line functional/no-throw-statements
+    throw new Error(
+      `Failed to fetch or parse schema from ${url}: ${error instanceof Error ? error.message : String(error)}`
+    )
+  }
+}

package/src/infrastructure/server/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/**
+ * Server Infrastructure Module
+ *
+ * Provides HTTP server creation, lifecycle management, and factory implementations.
+ * Uses Hono web framework with graceful shutdown support.
+ *
+ * @example
+ * ```typescript
+ * import { ServerFactoryLive } from '@/infrastructure/server'
+ *
+ * const program = startServer(config).pipe(
+ *   Effect.provide(ServerFactoryLive)
+ * )
+ * ```
+ */
+
+export { createServer } from './server'
+export { withGracefulShutdown } from './lifecycle'
+export { ServerFactoryLive } from './server-factory-live'

package/src/infrastructure/server/language-detection.ts

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { detectLanguageFromHeader } from '@/infrastructure/utils/accept-language-parser'
+import type { App } from '@/domain/models/app'
+
+/**
+ * Get array of supported language codes from app configuration
+ *
+ * @param app - Application configuration
+ * @returns Array of short language codes or empty array if languages not configured
+ *
+ * @example
+ * getSupportedLanguageCodes(app) // => ['en', 'fr', 'es']
+ */
+export function getSupportedLanguageCodes(app: App): ReadonlyArray<string> {
+  return app.languages?.supported.map((l) => l.code) || []
+}
+
+/**
+ * Extract and validate language code from URL path
+ *
+ * @param path - URL path (e.g., '/fr/', '/en/about')
+ * @param supportedLanguages - Array of supported short language codes
+ * @returns Short language code if valid, undefined otherwise
+ *
+ * @example
+ * extractLanguageFromPath('/fr/', ['en', 'fr']) // => 'fr'
+ * extractLanguageFromPath('/fr/about', ['en', 'fr']) // => 'fr'
+ * extractLanguageFromPath('/invalid/', ['en', 'fr']) // => undefined
+ * extractLanguageFromPath('/', ['en', 'fr']) // => undefined
+ */
+export function extractLanguageFromPath(
+  path: string,
+  supportedLanguages: ReadonlyArray<string>
+): string | undefined {
+  // Extract first path segment (e.g., '/fr-FR/about' => 'fr-FR')
+  const segments = path.split('/').filter(Boolean)
+  if (segments.length === 0) {
+    return undefined
+  }
+
+  const potentialLang = segments[0]
+  if (!potentialLang) {
+    return undefined
+  }
+
+  // Validate against supported languages
+  return supportedLanguages.includes(potentialLang) ? potentialLang : undefined
+}
+
+/**
+ * Detect language from Accept-Language header if browser detection is enabled
+ *
+ * @param app - Application configuration
+ * @param header - Accept-Language HTTP header value
+ * @returns Detected short language code or undefined
+ *
+ * @example
+ * detectLanguageIfEnabled(app, 'fr-FR,fr;q=0.9,en;q=0.8') // => 'fr'
+ * detectLanguageIfEnabled(appWithDetectionDisabled, 'fr-FR') // => undefined
+ */
+export function detectLanguageIfEnabled(app: App, header: string | undefined): string | undefined {
+  if (app.languages?.detectBrowser === false) {
+    return undefined
+  }
+  return detectLanguageFromHeader(header, getSupportedLanguageCodes(app))
+}
+
+/**
+ * Validate and extract language code from URL subdirectory path
+ *
+ * @param app - Application configuration
+ * @param path - URL path (e.g., '/fr/', '/en/about')
+ * @returns Short language code if valid subdirectory, undefined otherwise
+ *
+ * @example
+ * validateLanguageSubdirectory(app, '/fr/') // => 'fr'
+ * validateLanguageSubdirectory(app, '/products/pricing') // => undefined
+ */
+export function validateLanguageSubdirectory(app: App, path: string): string | undefined {
+  return extractLanguageFromPath(path, getSupportedLanguageCodes(app))
+}