sovrium 0.0.2

package/src/infrastructure/css/styles/component-layer-generators.ts

@@ -0,0 +1,147 @@
+/**
+ * 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 { generateClickAnimationCSS } from '@/infrastructure/css/styles/click-animations'
+import type { Theme } from '@/domain/models/app/theme'
+
+/**
+ * Build button classes with optional primary colors
+ *
+ * @param hasPrimaryColor - Whether theme defines primary color
+ * @param hasPrimaryHoverColor - Whether theme defines primary hover color
+ * @returns Array of CSS class names for button elements
+ */
+export function buildButtonClasses(
+  hasPrimaryColor: boolean,
+  hasPrimaryHoverColor: boolean
+): readonly string[] {
+  const baseClasses = [
+    'inline-flex',
+    'items-center',
+    'justify-center',
+    'rounded-md',
+    'px-4',
+    'py-2',
+    'font-medium',
+    'transition-colors',
+  ]
+
+  if (hasPrimaryColor && hasPrimaryHoverColor) {
+    return [...baseClasses, 'bg-primary', 'text-white', 'hover:bg-primary-hover']
+  }
+  if (hasPrimaryColor) {
+    return [...baseClasses, 'bg-primary', 'text-white']
+  }
+  return [...baseClasses, 'bg-blue-600', 'text-white', 'hover:bg-blue-700']
+}
+
+/**
+ * Build button primary utility classes
+ *
+ * @param hasPrimaryColor - Whether theme defines primary color
+ * @param hasPrimaryHoverColor - Whether theme defines primary hover color
+ * @returns CSS class string for primary button variant
+ */
+export function buildButtonPrimaryClasses(
+  hasPrimaryColor: boolean,
+  hasPrimaryHoverColor: boolean
+): string {
+  if (hasPrimaryColor && hasPrimaryHoverColor) {
+    return 'bg-primary text-white hover:bg-primary-hover'
+  }
+  if (hasPrimaryColor) {
+    return 'bg-primary text-white'
+  }
+  return 'bg-blue-600 text-white hover:bg-blue-700'
+}
+
+/**
+ * Build badge border-radius based on theme configuration
+ * Uses theme.borderRadius.full if defined, otherwise falls back to rounded-full
+ *
+ * @param theme - Optional theme configuration
+ * @returns CSS rule for badge border-radius
+ */
+export function buildBadgeBorderRadius(theme?: Theme): string {
+  const hasFullRadius = Boolean(theme?.borderRadius?.full)
+  return hasFullRadius ? 'border-radius: var(--radius-full);' : '@apply rounded-full;'
+}
+
+/**
+ * Generate components layer styles with theme color applications
+ * Applies theme colors to component classes and button elements
+ *
+ * @param theme - Optional theme configuration
+ * @returns CSS @layer components rule as string
+ *
+ * @example
+ * generateComponentsLayer(theme)
+ * // => '@layer components { .container-page { ... } .card { ... } ... }'
+ */
+export function generateComponentsLayer(theme?: Theme): string {
+  const hasPrimaryColor = Boolean(theme?.colors?.primary)
+  const hasPrimaryHoverColor = Boolean(theme?.colors?.['primary-hover'])
+
+  const btnClasses = buildButtonClasses(hasPrimaryColor, hasPrimaryHoverColor)
+  const btnPrimaryClasses = buildButtonPrimaryClasses(hasPrimaryColor, hasPrimaryHoverColor)
+  const badgeBorderRadius = buildBadgeBorderRadius(theme)
+
+  return `@layer components {
+      .container-page {
+        @apply mx-auto max-w-4xl px-4 py-8;
+      }
+
+      .card {
+        @apply rounded-lg border border-gray-200 bg-white p-6 shadow-sm;
+      }
+
+      .badge {
+        @apply border border-gray-200 bg-white px-2 py-1 text-xs font-medium;
+        ${badgeBorderRadius}
+      }
+
+      .btn {
+        @apply ${btnClasses.join(' ')};
+      }
+
+      .btn-primary {
+        @apply ${btnPrimaryClasses};
+      }
+    }`
+}
+
+/**
+ * Generate utilities layer styles
+ * Combines static utilities with click interaction animations
+ *
+ * @returns CSS @layer utilities rule as string
+ *
+ * @example
+ * generateUtilitiesLayer()
+ * // => '@layer utilities { .text-balance { ... } ... }'
+ */
+export function generateUtilitiesLayer(): string {
+  const clickAnimations = generateClickAnimationCSS()
+
+  return `@layer utilities {
+      .text-balance {
+        text-wrap: balance;
+      }
+
+      /* Safelist: Ensure critical utility classes are always included */
+      .text-center {
+        text-align: center;
+      }
+
+      /* Override Tailwind v4's multi-layer shadow system for shadow-none */
+      .shadow-none {
+        box-shadow: none !important;
+      }
+
+      ${clickAnimations}
+    }`
+}

package/src/infrastructure/css/theme/theme-generators.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 type { BorderRadiusConfig } from '@/domain/models/app/theme/border-radius'
+import type { BreakpointsConfig } from '@/domain/models/app/theme/breakpoints'
+import type { ColorsConfig } from '@/domain/models/app/theme/colors'
+import type { FontsConfig } from '@/domain/models/app/theme/fonts'
+import type { ShadowsConfig } from '@/domain/models/app/theme/shadows'
+import type { SpacingConfig } from '@/domain/models/app/theme/spacing'
+
+/**
+ * Generate Tailwind @theme colors from domain color config
+ * Uses hex format directly - Tailwind v4 handles color format conversion
+ */
+export function generateThemeColors(colors?: ColorsConfig): string {
+  if (!colors || Object.keys(colors).length === 0) return ''
+
+  const colorEntries = Object.entries(colors).map(([name, value]) => {
+    return `    --color-${name}: ${value};`
+  })
+
+  return colorEntries.join('\n')
+}
+
+/**
+ * Generate Tailwind @theme font families from domain font config
+ */
+export function generateThemeFonts(fonts?: FontsConfig): string {
+  if (!fonts || Object.keys(fonts).length === 0) return ''
+
+  const fontEntries = Object.entries(fonts).flatMap(([category, config]) => {
+    // Type assertion needed because Record values are unknown in TypeScript
+    const fontConfig = config as {
+      family: string
+      fallback?: string
+      style?: string
+      transform?: string
+      letterSpacing?: string
+    }
+    const fontStack = fontConfig.fallback
+      ? `${fontConfig.family}, ${fontConfig.fallback}`
+      : fontConfig.family
+
+    const baseEntry = `    --font-${category}: ${fontStack};`
+
+    // Build entries array immutably
+    const styleEntry =
+      fontConfig.style && fontConfig.style !== 'normal'
+        ? `    --font-${category}-style: ${fontConfig.style};`
+        : undefined
+
+    const transformEntry =
+      fontConfig.transform && fontConfig.transform !== 'none'
+        ? `    --font-${category}-transform: ${fontConfig.transform};`
+        : undefined
+
+    const letterSpacingEntry = fontConfig.letterSpacing
+      ? `    --font-${category}-letter-spacing: ${fontConfig.letterSpacing};`
+      : undefined
+
+    return [baseEntry, styleEntry, transformEntry, letterSpacingEntry].filter(
+      (entry): entry is string => entry !== undefined
+    )
+  })
+
+  return fontEntries.join('\n')
+}
+
+/**
+ * Generate Tailwind @theme spacing from domain spacing config
+ * Only includes raw CSS values (rem, px, em), not Tailwind classes
+ */
+export function generateThemeSpacing(spacing?: SpacingConfig): string {
+  if (!spacing || Object.keys(spacing).length === 0) return ''
+
+  const spacingEntries = Object.entries(spacing)
+    .filter(([_, value]) => {
+      // Only include raw CSS values (not Tailwind classes)
+      return /^[0-9.]+(?:rem|px|em|%)$/.test(value as string)
+    })
+    .map(([name, value]) => `    --spacing-${name}: ${value};`)
+
+  return spacingEntries.join('\n')
+}
+
+/**
+ * Generate Tailwind @theme shadows from domain shadow config
+ */
+export function generateThemeShadows(shadows?: ShadowsConfig): string {
+  if (!shadows || Object.keys(shadows).length === 0) return ''
+
+  const shadowEntries = Object.entries(shadows).map(([name, value]) => {
+    // Preserve original shadow values as-is
+    // The .shadow-none utility class override handles the actual rendering
+    return `    --shadow-${name}: ${value};`
+  })
+
+  return shadowEntries.join('\n')
+}
+
+/**
+ * Generate Tailwind @theme border radius from domain border radius config
+ */
+export function generateThemeBorderRadius(borderRadius?: BorderRadiusConfig): string {
+  if (!borderRadius || Object.keys(borderRadius).length === 0) return ''
+
+  const radiusEntries = Object.entries(borderRadius).map(([name, value]) => {
+    const key = name === 'DEFAULT' ? 'radius' : `radius-${name}`
+    return `    --${key}: ${value};`
+  })
+
+  return radiusEntries.join('\n')
+}
+
+/**
+ * Generate Tailwind @theme breakpoints from domain breakpoints config
+ */
+export function generateThemeBreakpoints(breakpoints?: BreakpointsConfig): string {
+  if (!breakpoints || Object.keys(breakpoints).length === 0) return ''
+
+  const breakpointEntries = Object.entries(breakpoints).map(
+    ([name, value]) => `    --breakpoint-${name}: ${value};`
+  )
+
+  return breakpointEntries.join('\n')
+}

package/src/infrastructure/css/theme/theme-layer-generators.ts

@@ -0,0 +1,219 @@
+/**
+ * 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 type { Theme } from '@/domain/models/app/theme'
+
+/**
+ * Theme color flags extracted from theme configuration
+ */
+export interface ThemeColorFlags {
+  readonly hasTextColor: boolean
+  readonly hasPrimaryColor: boolean
+  readonly hasPrimaryHoverColor: boolean
+}
+
+/**
+ * Theme font flags extracted from theme configuration
+ */
+export interface ThemeFontFlags {
+  readonly hasTitleFont: boolean
+  readonly hasBodyFont: boolean
+}
+
+/**
+ * Title font configuration type
+ */
+export interface TitleFontConfig {
+  readonly style?: string
+  readonly transform?: string
+  readonly letterSpacing?: string
+}
+
+/**
+ * Extract color availability flags from theme
+ * Returns flags indicating which colors are defined in the theme
+ *
+ * @param theme - Optional theme configuration
+ * @returns Object with color availability flags
+ */
+export function extractThemeColorFlags(theme?: Theme): ThemeColorFlags {
+  return {
+    hasTextColor: Boolean(theme?.colors?.text),
+    hasPrimaryColor: Boolean(theme?.colors?.primary),
+    hasPrimaryHoverColor: Boolean(theme?.colors?.['primary-hover']),
+  }
+}
+
+/**
+ * Extract font availability flags from theme
+ * Returns flags indicating which fonts are defined in the theme
+ *
+ * @param theme - Optional theme configuration
+ * @returns Object with font availability flags
+ */
+export function extractThemeFontFlags(theme?: Theme): ThemeFontFlags {
+  return {
+    hasTitleFont: Boolean(theme?.fonts?.title),
+    hasBodyFont: Boolean(theme?.fonts?.body),
+  }
+}
+
+/**
+ * Extract title font properties from theme fonts config
+ * Returns undefined if no title font is configured
+ *
+ * @param theme - Optional theme configuration
+ * @returns Title font configuration or undefined
+ */
+export function extractTitleFontProperties(theme?: Theme): TitleFontConfig | undefined {
+  if (!theme?.fonts?.title || typeof theme.fonts.title !== 'object') {
+    return undefined
+  }
+
+  return theme.fonts.title as TitleFontConfig
+}
+
+/**
+ * Build body classes with optional text color and font
+ *
+ * @param hasTextColor - Whether theme defines text color
+ * @param hasBodyFont - Whether theme defines body font
+ * @returns Array of CSS class names for body element
+ */
+export function buildBodyClasses(hasTextColor: boolean, hasBodyFont: boolean): readonly string[] {
+  const fontClass = hasBodyFont ? 'font-body' : 'font-sans'
+  return hasTextColor ? [fontClass, 'antialiased', 'text-text'] : [fontClass, 'antialiased']
+}
+
+/**
+ * Build heading classes with optional text color and font
+ *
+ * @param hasTextColor - Whether theme defines text color
+ * @param hasTitleFont - Whether theme defines title font
+ * @returns Array of CSS class names for heading elements
+ */
+export function buildHeadingClasses(
+  hasTextColor: boolean,
+  hasTitleFont: boolean
+): readonly string[] {
+  const fontClass = hasTitleFont ? 'font-title' : 'font-sans'
+  const baseClasses = hasTextColor
+    ? [fontClass, 'font-semibold', 'tracking-tight', 'text-text']
+    : [fontClass, 'font-semibold', 'tracking-tight']
+  return baseClasses
+}
+
+/**
+ * Build link classes with optional primary colors
+ *
+ * @param hasPrimaryColor - Whether theme defines primary color
+ * @param hasPrimaryHoverColor - Whether theme defines primary hover color
+ * @returns Array of CSS class names for link elements
+ */
+export function buildLinkClasses(
+  hasPrimaryColor: boolean,
+  hasPrimaryHoverColor: boolean
+): readonly string[] {
+  if (hasPrimaryColor && hasPrimaryHoverColor) {
+    return ['transition-colors', 'text-primary', 'hover:text-primary-hover']
+  }
+  if (hasPrimaryColor) {
+    return ['transition-colors', 'text-primary']
+  }
+  return ['transition-colors', 'text-blue-600', 'hover:text-blue-700']
+}
+
+/**
+ * Build CSS property strings for heading styles
+ * Returns array of CSS properties based on title font configuration
+ *
+ * @param titleFont - Optional title font configuration
+ * @returns Array of CSS property strings
+ */
+export function buildHeadingStyleProperties(titleFont?: TitleFontConfig): readonly string[] {
+  if (!titleFont) return []
+
+  const styleProperty =
+    titleFont.style && titleFont.style !== 'normal'
+      ? `font-style: var(--font-title-style);`
+      : undefined
+
+  const transformProperty =
+    titleFont.transform && titleFont.transform !== 'none'
+      ? `text-transform: var(--font-title-transform);`
+      : undefined
+
+  const letterSpacingProperty = titleFont.letterSpacing
+    ? `letter-spacing: var(--font-title-letter-spacing);`
+    : undefined
+
+  return [styleProperty, transformProperty, letterSpacingProperty].filter(
+    (prop): prop is string => prop !== undefined
+  )
+}
+
+/**
+ * Generate heading CSS with base classes and optional style properties
+ * Combines heading classes with additional CSS properties
+ *
+ * @param headingClasses - Array of CSS class names
+ * @param styleProps - Array of CSS property strings
+ * @returns Complete CSS rule for headings
+ */
+export function generateHeadingStyles(
+  headingClasses: readonly string[],
+  styleProps: readonly string[]
+): string {
+  const baseStyles = `@apply ${headingClasses.join(' ')};`
+  if (styleProps.length === 0) return baseStyles
+
+  return `${baseStyles}
+        ${styleProps.join('\n        ')}`
+}
+
+/**
+ * Generate base layer styles with theme color and font applications
+ * Applies theme colors and fonts to base HTML elements if theme defines those tokens
+ *
+ * @param theme - Optional theme configuration
+ * @returns CSS @layer base rule as string
+ *
+ * @example
+ * generateBaseLayer(theme)
+ * // => '@layer base { body { ... } h1, h2, ... { ... } a { ... } }'
+ */
+export function generateBaseLayer(theme?: Theme): string {
+  const colorFlags = extractThemeColorFlags(theme)
+  const fontFlags = extractThemeFontFlags(theme)
+
+  const bodyClasses = buildBodyClasses(colorFlags.hasTextColor, fontFlags.hasBodyFont)
+  const headingClasses = buildHeadingClasses(colorFlags.hasTextColor, fontFlags.hasTitleFont)
+  const linkClasses = buildLinkClasses(colorFlags.hasPrimaryColor, colorFlags.hasPrimaryHoverColor)
+
+  const titleFont = extractTitleFontProperties(theme)
+  const headingStyleProps = buildHeadingStyleProperties(titleFont)
+  const headingStyles = generateHeadingStyles(headingClasses, headingStyleProps)
+
+  return `@layer base {
+      body {
+        @apply ${bodyClasses.join(' ')};
+      }
+
+      h1,
+      h2,
+      h3,
+      h4,
+      h5,
+      h6 {
+        ${headingStyles}
+      }
+
+      a {
+        @apply ${linkClasses.join(' ')};
+      }
+    }`
+}

package/src/infrastructure/css/theme/theme-token-resolver.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 type { Theme } from '@/domain/models/app/theme'
+
+/**
+ * Resolve color token reference
+ *
+ * @param tokenName - Name of the color token (e.g., 'primary', 'text')
+ * @param theme - Optional theme configuration
+ * @returns Resolved color value or undefined if token not found
+ *
+ * @example
+ * resolveColorToken('primary', theme) // => '#ff5733'
+ * resolveColorToken('unknown', theme) // => undefined
+ */
+export function resolveColorToken(tokenName: string, theme?: Theme): string | undefined {
+  if (!theme?.colors || !(tokenName in theme.colors)) return undefined
+  const colorValue = theme.colors[tokenName]
+  return colorValue ? String(colorValue) : undefined
+}
+
+/**
+ * Resolve easing token reference
+ *
+ * @param tokenName - Name of the easing token (e.g., 'smooth', 'bounce')
+ * @param theme - Optional theme configuration
+ * @returns Resolved easing value or undefined if token not found
+ *
+ * @example
+ * resolveEasingToken('smooth', theme) // => 'cubic-bezier(0.4, 0, 0.2, 1)'
+ * resolveEasingToken('unknown', theme) // => undefined
+ */
+export function resolveEasingToken(tokenName: string, theme?: Theme): string | undefined {
+  if (!theme?.animations) return undefined
+  const animations = theme.animations as Record<string, unknown>
+  const easingTokens = animations.easing as Record<string, unknown> | undefined
+  if (!easingTokens || typeof easingTokens !== 'object' || !(tokenName in easingTokens))
+    return undefined
+  const easingValue = easingTokens[tokenName]
+  return easingValue ? String(easingValue) : undefined
+}
+
+/**
+ * Resolve token references in a value
+ * Supports: $colors.primary, $easing.smooth, etc.
+ *
+ * @param value - Value to resolve (can be string with token reference or any other type)
+ * @param theme - Optional theme configuration
+ * @returns Resolved value as string
+ *
+ * @example
+ * resolveTokenReference('$colors.primary', theme) // => '#ff5733'
+ * resolveTokenReference('$easing.smooth', theme) // => 'cubic-bezier(0.4, 0, 0.2, 1)'
+ * resolveTokenReference('plain-value', theme) // => 'plain-value'
+ * resolveTokenReference(42, theme) // => '42'
+ */
+export function resolveTokenReference(value: unknown, theme?: Theme): string {
+  if (typeof value !== 'string') return String(value)
+
+  const tokenMatch = value.match(/^\$(\w+)\.(\w+)$/)
+  if (!tokenMatch) return value
+
+  const [, category, tokenName] = tokenMatch
+  if (!category || !tokenName) return value
+
+  return (
+    (category === 'colors' ? resolveColorToken(tokenName, theme) : undefined) ??
+    (category === 'easing' ? resolveEasingToken(tokenName, theme) : undefined) ??
+    value
+  )
+}

package/src/infrastructure/database/activity-queries.ts

@@ -0,0 +1,111 @@
+/**
+ * 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 { eq } from 'drizzle-orm'
+import { Effect } from 'effect'
+import { Database, activityLogs, users } from '@/infrastructure/database'
+
+/**
+ * Activity log with user metadata
+ */
+export interface ActivityLogWithUser {
+  readonly id: string
+  readonly userId: string
+  readonly action: string
+  readonly tableName: string
+  readonly recordId: number
+  readonly changes: Record<string, unknown> | null
+  readonly createdAt: Date
+  readonly user: {
+    readonly id: string
+    readonly name: string
+    readonly email: string
+  }
+}
+
+/**
+ * Database error for activity queries
+ */
+export class ActivityDatabaseError {
+  readonly _tag = 'ActivityDatabaseError'
+  constructor(readonly cause: unknown) {}
+}
+
+/**
+ * Activity not found error
+ */
+export class ActivityNotFoundError {
+  readonly _tag = 'ActivityNotFoundError'
+  constructor(readonly activityId: string) {}
+}
+
+/**
+ * Get activity log by ID with user metadata
+ *
+ * Fetches activity log details with a JOIN to the users table to include
+ * user information (name, email).
+ *
+ * @param activityId - Activity log ID (UUID string or numeric string)
+ * @returns Effect program that resolves to activity with user metadata or fails with error
+ */
+export const getActivityById = (activityId: string) =>
+  Effect.gen(function* () {
+    const db = yield* Database
+
+    const result = yield* Effect.tryPromise({
+      try: () =>
+        db
+          .select({
+            id: activityLogs.id,
+            userId: activityLogs.userId,
+            action: activityLogs.action,
+            tableName: activityLogs.tableName,
+            recordId: activityLogs.recordId,
+            changes: activityLogs.changes,
+            createdAt: activityLogs.createdAt,
+            userName: users.name,
+            userEmail: users.email,
+            userIdJoined: users.id,
+          })
+          .from(activityLogs)
+          .leftJoin(users, eq(activityLogs.userId, users.id))
+          .where(eq(activityLogs.id, activityId))
+          .limit(1),
+      catch: (error) => new ActivityDatabaseError(error),
+    })
+
+    if (result.length === 0 || !result[0]) {
+      return yield* Effect.fail(new ActivityNotFoundError(activityId))
+    }
+
+    const row = result[0]
+
+    // Parse recordId as integer (stored as text in DB)
+    const recordIdInt = parseInt(row.recordId, 10)
+    const recordId = isNaN(recordIdInt) ? 0 : recordIdInt
+
+    // Changes is already JSONB (parsed by Drizzle), cast to expected type
+    // eslint-disable-next-line unicorn/no-null -- Null is intentional for JSONB columns with no data
+    const changes = (row.changes as Record<string, unknown> | null) ?? null
+
+    const activity: ActivityLogWithUser = {
+      id: row.id,
+      userId: row.userId ?? '',
+      action: row.action,
+      tableName: row.tableName,
+      recordId,
+      changes,
+      createdAt: row.createdAt,
+      user: {
+        id: row.userIdJoined ?? '',
+        name: row.userName ?? '',
+        email: row.userEmail ?? '',
+      },
+    }
+
+    return activity
+  })