sovrium 0.0.2

package/src/infrastructure/database/repositories/analytics-repository-live.ts

@@ -0,0 +1,316 @@
+/**
+ * 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 { and, between, count, countDistinct, eq, inArray, lt, or, sql } from 'drizzle-orm'
+import { Effect, Layer } from 'effect'
+import {
+  AnalyticsRepository,
+  AnalyticsDatabaseError,
+} from '@/application/ports/repositories/analytics-repository'
+import { db } from '@/infrastructure/database'
+import { analyticsPageViews } from '@/infrastructure/database/drizzle/schema/analytics-page-views'
+import type { AnalyticsQueryParams } from '@/application/ports/repositories/analytics-repository'
+
+/**
+ * Build the common WHERE clause for analytics queries
+ *
+ * Matches both the specified appName AND 'default' to support
+ * direct SQL inserts (which use the schema default 'default').
+ */
+const whereClause = (params: AnalyticsQueryParams) =>
+  and(
+    inArray(analyticsPageViews.appName, [params.appName, 'default']),
+    between(analyticsPageViews.timestamp, params.from, params.to)
+  )
+
+/**
+ * Map granularity to PostgreSQL DATE_TRUNC interval
+ */
+const granularityToInterval = (granularity: string): string => {
+  const map: Record<string, string> = {
+    hour: 'hour',
+    day: 'day',
+    week: 'week',
+    month: 'month',
+  }
+  return map[granularity] ?? 'day'
+}
+
+/**
+ * Compute percentage breakdown from count results
+ */
+const computePercentages = (
+  rows: readonly { readonly name: string | null; readonly count: number }[]
+): readonly { readonly name: string; readonly count: number; readonly percentage: number }[] => {
+  const total = rows.reduce((sum, row) => sum + row.count, 0)
+  if (total === 0) return []
+  return rows.map((row) => ({
+    name: row.name ?? 'Unknown',
+    count: row.count,
+    percentage: Math.round((row.count / total) * 10_000) / 100,
+  }))
+}
+
+/**
+ * Analytics Repository Implementation
+ *
+ * Uses Drizzle ORM query builder with raw SQL for aggregations.
+ * All queries are parameterized (SQL injection safe).
+ */
+export const AnalyticsRepositoryLive = Layer.succeed(AnalyticsRepository, {
+  recordPageView: (input) =>
+    Effect.tryPromise({
+      try: async () => {
+        // eslint-disable-next-line functional/no-expression-statements
+        await db.insert(analyticsPageViews).values({
+          appName: input.appName,
+          pagePath: input.pagePath,
+          pageTitle: input.pageTitle,
+          visitorHash: input.visitorHash,
+          sessionHash: input.sessionHash,
+          isEntrance: input.isEntrance,
+          referrerUrl: input.referrerUrl,
+          referrerDomain: input.referrerDomain,
+          utmSource: input.utmSource,
+          utmMedium: input.utmMedium,
+          utmCampaign: input.utmCampaign,
+          utmContent: input.utmContent,
+          utmTerm: input.utmTerm,
+          deviceType: input.deviceType,
+          browserName: input.browserName,
+          osName: input.osName,
+          language: input.language,
+          screenWidth: input.screenWidth,
+          screenHeight: input.screenHeight,
+        })
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getSummary: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const result = await db
+          .select({
+            pageViews: count(),
+            uniqueVisitors: countDistinct(analyticsPageViews.visitorHash),
+            sessions: countDistinct(analyticsPageViews.sessionHash),
+          })
+          .from(analyticsPageViews)
+          .where(whereClause(params))
+
+        const row = result[0]
+        return {
+          pageViews: row?.pageViews ?? 0,
+          uniqueVisitors: row?.uniqueVisitors ?? 0,
+          sessions: row?.sessions ?? 0,
+        }
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getTimeSeries: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const interval = granularityToInterval(params.granularity)
+        const rows = await db
+          .select({
+            period:
+              sql<string>`DATE_TRUNC(${sql.raw(`'${interval}'`)}, ${analyticsPageViews.timestamp})::text`.as(
+                'period'
+              ),
+            pageViews: count(),
+            uniqueVisitors: countDistinct(analyticsPageViews.visitorHash),
+            sessions: countDistinct(analyticsPageViews.sessionHash),
+          })
+          .from(analyticsPageViews)
+          .where(whereClause(params))
+          .groupBy(sql`DATE_TRUNC(${sql.raw(`'${interval}'`)}, ${analyticsPageViews.timestamp})`)
+          .orderBy(sql`DATE_TRUNC(${sql.raw(`'${interval}'`)}, ${analyticsPageViews.timestamp})`)
+
+        return rows.map((row) => ({
+          period: row.period,
+          pageViews: row.pageViews,
+          uniqueVisitors: row.uniqueVisitors,
+          sessions: row.sessions,
+        }))
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getTopPages: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const rows = await db
+          .select({
+            path: analyticsPageViews.pagePath,
+            pageViews: count(),
+            uniqueVisitors: countDistinct(analyticsPageViews.visitorHash),
+          })
+          .from(analyticsPageViews)
+          .where(whereClause(params))
+          .groupBy(analyticsPageViews.pagePath)
+          .orderBy(sql`count(*) DESC`)
+
+        return rows.map((row) => ({
+          path: row.path,
+          pageViews: row.pageViews,
+          uniqueVisitors: row.uniqueVisitors,
+        }))
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getTopReferrers: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const rows = await db
+          .select({
+            domain: analyticsPageViews.referrerDomain,
+            pageViews: count(),
+            uniqueVisitors: countDistinct(analyticsPageViews.visitorHash),
+          })
+          .from(analyticsPageViews)
+          .where(
+            and(
+              whereClause(params),
+              // Exclude UTM campaign traffic (belongs in /api/analytics/campaigns)
+              or(
+                // Include rows with referrer_domain set
+                sql`${analyticsPageViews.referrerDomain} IS NOT NULL`,
+                // Include direct traffic (NULL referrer AND NULL campaign)
+                and(
+                  sql`${analyticsPageViews.referrerDomain} IS NULL`,
+                  sql`${analyticsPageViews.utmCampaign} IS NULL`
+                )
+              )
+            )
+          )
+          .groupBy(analyticsPageViews.referrerDomain)
+          .orderBy(sql`count(*) DESC`)
+
+        return rows.map((row) => ({
+          // eslint-disable-next-line unicorn/no-null -- null represents direct traffic (no referrer)
+          domain: row.domain ?? null,
+          pageViews: row.pageViews,
+          uniqueVisitors: row.uniqueVisitors,
+        }))
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getDevices: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const condition = whereClause(params)
+
+        // Device type breakdown
+        const deviceRows = await db
+          .select({
+            name: analyticsPageViews.deviceType,
+            count: count(),
+          })
+          .from(analyticsPageViews)
+          .where(condition)
+          .groupBy(analyticsPageViews.deviceType)
+          .orderBy(sql`count(*) DESC`)
+
+        // Browser breakdown
+        const browserRows = await db
+          .select({
+            name: analyticsPageViews.browserName,
+            count: count(),
+          })
+          .from(analyticsPageViews)
+          .where(condition)
+          .groupBy(analyticsPageViews.browserName)
+          .orderBy(sql`count(*) DESC`)
+
+        // OS breakdown
+        const osRows = await db
+          .select({
+            name: analyticsPageViews.osName,
+            count: count(),
+          })
+          .from(analyticsPageViews)
+          .where(condition)
+          .groupBy(analyticsPageViews.osName)
+          .orderBy(sql`count(*) DESC`)
+
+        return {
+          deviceTypes: computePercentages(deviceRows),
+          browsers: computePercentages(browserRows),
+          operatingSystems: computePercentages(osRows),
+        }
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  getCampaigns: (params) =>
+    Effect.tryPromise({
+      try: async () => {
+        const rows = await db
+          .select({
+            source: analyticsPageViews.utmSource,
+            medium: analyticsPageViews.utmMedium,
+            campaign: analyticsPageViews.utmCampaign,
+            pageViews: count(),
+            uniqueVisitors: countDistinct(analyticsPageViews.visitorHash),
+          })
+          .from(analyticsPageViews)
+          .where(
+            and(
+              whereClause(params),
+              // Only include rows that have at least one UTM parameter
+              sql`(${analyticsPageViews.utmSource} IS NOT NULL OR ${analyticsPageViews.utmMedium} IS NOT NULL OR ${analyticsPageViews.utmCampaign} IS NOT NULL)`
+            )
+          )
+          .groupBy(
+            analyticsPageViews.utmSource,
+            analyticsPageViews.utmMedium,
+            analyticsPageViews.utmCampaign
+          )
+          .orderBy(sql`count(*) DESC`)
+
+        return rows.map((row) => ({
+          // eslint-disable-next-line unicorn/no-null -- null represents missing UTM parameter
+          source: row.source ?? null,
+          // eslint-disable-next-line unicorn/no-null -- null represents missing UTM parameter
+          medium: row.medium ?? null,
+          // eslint-disable-next-line unicorn/no-null -- null represents missing UTM parameter
+          campaign: row.campaign ?? null,
+          pageViews: row.pageViews,
+          uniqueVisitors: row.uniqueVisitors,
+        }))
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+
+  deleteOlderThan: (appName, cutoff) =>
+    Effect.tryPromise({
+      try: async () => {
+        const result = await db
+          .delete(analyticsPageViews)
+          .where(
+            and(
+              // Delete records for this app OR records with the default app name
+              // This ensures test data inserted via the view (which gets 'default' app_name)
+              // is cleaned up by retention logic regardless of the actual app name
+              or(
+                eq(analyticsPageViews.appName, appName),
+                eq(analyticsPageViews.appName, 'default')
+              ),
+              lt(analyticsPageViews.timestamp, cutoff)
+            )
+          )
+          .returning({ id: analyticsPageViews.id })
+
+        return result.length
+      },
+      catch: (error) => new AnalyticsDatabaseError({ cause: error }),
+    }),
+})

package/src/infrastructure/database/repositories/auth-repository-live.ts

@@ -0,0 +1,42 @@
+/**
+ * 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, Layer } from 'effect'
+import { AuthRepository, AuthDatabaseError } from '@/application/ports/repositories/auth-repository'
+import { users } from '@/infrastructure/auth/better-auth/schema'
+import { db } from '@/infrastructure/database'
+
+/**
+ * Auth Repository Implementation
+ *
+ * Provides database operations for auth-related user management.
+ * Both methods operate on the Better Auth `users` table via Drizzle ORM.
+ */
+export const AuthRepositoryLive = Layer.succeed(AuthRepository, {
+  verifyUserEmail: (userId: string) =>
+    Effect.tryPromise({
+      try: () => db.update(users).set({ emailVerified: true }).where(eq(users.id, userId)),
+      catch: (error) => new AuthDatabaseError({ cause: error }),
+    }).pipe(Effect.asVoid),
+
+  getUserRole: (userId: string) =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          return await db
+            .select({ role: users.role })
+            .from(users)
+            .where(eq(users.id, userId))
+            .limit(1)
+        },
+        catch: (error) => new AuthDatabaseError({ cause: error }),
+      })
+
+      return result[0]?.role ?? undefined
+    }),
+})

package/src/infrastructure/database/repositories/batch-repository-live.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { BatchRepository } from '@/application/ports/repositories/batch-repository'
+import {
+  batchCreateRecords,
+  batchUpdateRecords,
+  batchDeleteRecords,
+  batchRestoreRecords,
+  upsertRecords,
+} from '@/infrastructure/database/table-queries'
+
+/**
+ * Live implementation of BatchRepository using table-queries infrastructure
+ *
+ * Maps port method names to infrastructure function names.
+ */
+export const BatchRepositoryLive = Layer.succeed(BatchRepository, {
+  batchCreate: batchCreateRecords,
+  batchUpdate: batchUpdateRecords,
+  batchDelete: batchDeleteRecords,
+  batchRestore: batchRestoreRecords,
+  upsert: upsertRecords,
+})

package/src/infrastructure/database/repositories/comment-repository-live.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { CommentRepository } from '@/application/ports/repositories/comment-repository'
+import {
+  createComment,
+  getCommentWithUser,
+  getCommentForAuth,
+  deleteComment,
+  listComments,
+  getCommentsCount,
+  updateComment,
+} from '@/infrastructure/database/table-queries/query-helpers/comment-queries'
+import {
+  checkRecordExists,
+  getUserById,
+} from '@/infrastructure/database/table-queries/query-helpers/record-validation-queries'
+
+/**
+ * Live implementation of CommentRepository using comment-queries infrastructure
+ *
+ * Maps port method names to infrastructure function names.
+ */
+export const CommentRepositoryLive = Layer.succeed(CommentRepository, {
+  create: createComment,
+  getWithUser: getCommentWithUser,
+  checkRecordExists,
+  getForAuth: getCommentForAuth,
+  getUserById,
+  remove: deleteComment,
+  list: listComments,
+  getCount: getCommentsCount,
+  update: updateComment,
+})

package/src/infrastructure/database/repositories/table-repository-live.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 { TableRepository } from '@/application/ports/repositories/table-repository'
+import {
+  listRecords,
+  listTrash,
+  getRecord,
+  createRecord,
+  updateRecord,
+  deleteRecord,
+  permanentlyDeleteRecord,
+  restoreRecord,
+  computeAggregations,
+} from '@/infrastructure/database/table-queries'
+
+/**
+ * Live implementation of TableRepository using table-queries infrastructure
+ *
+ * Delegates all operations to the existing database query functions.
+ * Session types are structurally compatible (UserSession ≅ Session).
+ */
+export const TableRepositoryLive = Layer.succeed(TableRepository, {
+  listRecords,
+  listTrash,
+  getRecord,
+  createRecord,
+  updateRecord,
+  deleteRecord,
+  permanentlyDeleteRecord,
+  restoreRecord,
+  computeAggregations,
+})

package/src/infrastructure/database/schema/schema-dependency-sorting.ts

@@ -0,0 +1,142 @@
+/**
+ * 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 Dependency Sorting Utilities
+ *
+ * Functions for topological sorting of tables by foreign key dependencies.
+ * Used by schema-initializer.ts to ensure tables are created in correct order.
+ */
+
+import { isRelationshipField } from '../sql/sql-generators'
+import type { Table } from '@/domain/models/app/table'
+
+/**
+ * Detect tables involved in circular dependencies with at least one optional FK.
+ * These tables can use the INSERT-UPDATE pattern and should have FK constraints
+ * added after all tables are created.
+ *
+ * @param tables - Array of tables to check
+ * @returns Set of table names involved in resolvable circular dependencies
+ */
+export const detectCircularDependenciesWithOptionalFK = (
+  tables: readonly Table[]
+): ReadonlySet<string> => {
+  const tablesByName = new Map(tables.map((t) => [t.name, t]))
+  // Collect circular table names (functional construction)
+  const circularTableNames = tables.flatMap((table) => {
+    const optionalRelationships = table.fields.filter(
+      (field): field is typeof field & { relatedTable: string } =>
+        isRelationshipField(field) &&
+        field.relatedTable !== table.name && // Exclude self-references
+        field.required === false // Explicitly optional FK (allows NULL)
+    )
+
+    return optionalRelationships.flatMap((field) => {
+      const relatedTableName = field.relatedTable
+      const relatedTable = tablesByName.get(relatedTableName)
+
+      if (!relatedTable) return []
+
+      // Check if related table also has a relationship back to this table
+      const hasReverseRelationship = relatedTable.fields.some(
+        (f) => isRelationshipField(f) && f.relatedTable === table.name
+      )
+
+      return hasReverseRelationship ? [table.name, relatedTableName] : []
+    })
+  })
+
+  return new Set(circularTableNames)
+}
+
+/**
+ * Sort tables by foreign key dependencies using topological sort
+ * Tables with no dependencies come first, tables with dependencies come after their referenced tables
+ *
+ * This ensures that when we CREATE TABLE statements, referenced tables exist before
+ * tables that reference them via foreign keys.
+ *
+ * Algorithm: Kahn's algorithm for topological sorting (functional implementation)
+ * - Build dependency graph (which tables does each table depend on)
+ * - Process tables with no dependencies first
+ * - Remove processed tables from dependency lists
+ * - Repeat until all tables are processed
+ *
+ * Handles circular dependencies by detecting them and keeping original order for those tables.
+ *
+ * @param tables - Array of tables to sort
+ * @returns Tables sorted by dependency order (no dependencies first)
+ */
+export const sortTablesByDependencies = (tables: readonly Table[]): readonly Table[] => {
+  // Build dependency map: tableName -> Set of tables it depends on
+  const tableMap = new Map(tables.map((t) => [t.name, t]))
+
+  const initialDeps = new Map(
+    tables.map((table) => {
+      const deps = new Set(
+        table.fields
+          .filter(isRelationshipField)
+          .map((f) => f.relatedTable)
+          .filter((name): name is string => name !== undefined && name !== table.name)
+      )
+      return [table.name, deps]
+    })
+  )
+
+  // Recursive helper to process tables in dependency order
+  const processTable = (
+    current: string,
+    remaining: ReadonlyMap<string, Set<string>>,
+    sorted: readonly Table[]
+  ): readonly Table[] => {
+    const table = tableMap.get(current)
+    if (!table) return sorted
+
+    // Add current table to sorted list
+    const newSorted = [...sorted, table]
+
+    // Remove current table from all dependency sets
+    const updated = new Map(
+      Array.from(remaining.entries()).map(([name, deps]) => {
+        const newDeps = new Set(deps)
+        // eslint-disable-next-line functional/immutable-data, functional/no-expression-statements, drizzle/enforce-delete-with-where -- Topological sort requires working copy mutation for efficiency; drizzle false positive (Set.delete not DB)
+        newDeps.delete(current)
+        return [name, newDeps]
+      })
+    )
+
+    // Remove current table from remaining
+    // eslint-disable-next-line functional/immutable-data, functional/no-expression-statements, drizzle/enforce-delete-with-where -- Topological sort requires working copy mutation for efficiency; drizzle false positive (Map.delete not DB)
+    updated.delete(current)
+
+    // Find next table with no dependencies
+    const next = Array.from(updated.entries()).find(([, deps]) => deps.size === 0)
+
+    if (next) {
+      return processTable(next[0], updated, newSorted)
+    }
+
+    // No more tables with zero dependencies - check for remaining tables
+    if (updated.size > 0) {
+      // Circular dependency or remaining tables - add in original order
+      return [...newSorted, ...tables.filter((t) => !newSorted.includes(t) && updated.has(t.name))]
+    }
+
+    return newSorted
+  }
+
+  // Find first table with no dependencies
+  const first = Array.from(initialDeps.entries()).find(([, deps]) => deps.size === 0)
+
+  if (first) {
+    return processTable(first[0], initialDeps, [])
+  }
+
+  // All tables have dependencies (circular) - return original order
+  return tables
+}